// **********************************************************************
//
// Copyright (c) 2003-2008 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************

// Ice version 3.3.0
// Generated from file `Integration.ice'

#include "Integration.h"
#include <Ice/LocalException.h>
#include <Ice/ObjectFactory.h>
#include <Ice/BasicStream.h>
#include <IceUtil/Iterator.h>
#include <IceUtil/ScopedArray.h>

#ifndef ICE_IGNORE_VERSION
#   if ICE_INT_VERSION / 100 != 303
#       error Ice version mismatch!
#   endif
#   if ICE_INT_VERSION % 100 > 50
#       error Beta header file detected
#   endif
#   if ICE_INT_VERSION % 100 < 0
#       error Ice patch level mismatch!
#   endif
#endif

static const ::std::string __CustomerRelationsManagement__customer__getId_name = "getId";

static const ::std::string __CustomerRelationsManagement__customer__save_name = "save";

static const ::std::string __CustomerRelationsManagement__customer__delete_name = "delete";

static const ::std::string __CustomerRelationsManagement__customer__getName_name = "getName";

static const ::std::string __CustomerRelationsManagement__customer__setName_name = "setName";

static const ::std::string __CustomerRelationsManagement__order__getId_name = "getId";

static const ::std::string __CustomerRelationsManagement__order__save_name = "save";

static const ::std::string __CustomerRelationsManagement__order__delete_name = "delete";

static const ::std::string __CustomerRelationsManagement__order__getCustomer_name = "getCustomer";

static const ::std::string __CustomerRelationsManagement__order__setCustomer_name = "setCustomer";

static const ::std::string __CustomerRelationsManagement__order__getSrc_name = "getSrc";

static const ::std::string __CustomerRelationsManagement__order__getDst_name = "getDst";

static const ::std::string __CustomerRelationsManagement__order__setSrc_name = "setSrc";

static const ::std::string __CustomerRelationsManagement__order__setDst_name = "setDst";

static const ::std::string __CustomerRelationsManagement__order__getWeight_name = "getWeight";

static const ::std::string __CustomerRelationsManagement__order__setWeight_name = "setWeight";

static const ::std::string __CustomerRelationsManagement__order__getDeadline_name = "getDeadline";

static const ::std::string __CustomerRelationsManagement__order__setDeadline_name = "setDeadline";

static const ::std::string __CustomerRelationsManagement__order__getStatus_name = "getStatus";

static const ::std::string __CustomerRelationsManagement__order__setStatus_name = "setStatus";

static const ::std::string __CustomerRelationsManagement__CRM__CreateCustomer_name = "CreateCustomer";

static const ::std::string __CustomerRelationsManagement__CRM__LoadCustomerByName_name = "LoadCustomerByName";

static const ::std::string __CustomerRelationsManagement__CRM__LoadCustomerById_name = "LoadCustomerById";

static const ::std::string __CustomerRelationsManagement__CRM__CreateOrder_name = "CreateOrder";

static const ::std::string __CustomerRelationsManagement__CRM__LoadOrderById_name = "LoadOrderById";

static const ::std::string __CustomerRelationsManagement__CRM__LoadOrderByCustomer_name = "LoadOrderByCustomer";

static const ::std::string __CustomerRelationsManagement__CRM__LoadNewOrders_name = "LoadNewOrders";

static const ::std::string __Optimization__OptimizationEngine__runTest_name = "runTest";

static const ::std::string __Tracking__TrackingService__getAllData_name = "getAllData";

static const ::std::string __Tracking__TrackingService__postNewRoutes_name = "postNewRoutes";

::Ice::Object* IceInternal::upCast(::CustomerRelationsManagement::customer* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::CustomerRelationsManagement::customer* p) { return p; }

::Ice::Object* IceInternal::upCast(::CustomerRelationsManagement::order* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::CustomerRelationsManagement::order* p) { return p; }

::Ice::Object* IceInternal::upCast(::CustomerRelationsManagement::CRM* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::CustomerRelationsManagement::CRM* p) { return p; }

::Ice::Object* IceInternal::upCast(::Optimization::OptimizationEngine* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Optimization::OptimizationEngine* p) { return p; }

::Ice::Object* IceInternal::upCast(::Tracking::TrackingService* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Tracking::TrackingService* p) { return p; }

void
CustomerRelationsManagement::__read(::IceInternal::BasicStream* __is, ::CustomerRelationsManagement::customerPrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::CustomerRelationsManagement::customer;
        v->__copyFrom(proxy);
    }
}

void
CustomerRelationsManagement::__read(::IceInternal::BasicStream* __is, ::CustomerRelationsManagement::orderPrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::CustomerRelationsManagement::order;
        v->__copyFrom(proxy);
    }
}

void
CustomerRelationsManagement::__read(::IceInternal::BasicStream* __is, ::CustomerRelationsManagement::CRMPrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::CustomerRelationsManagement::CRM;
        v->__copyFrom(proxy);
    }
}

void
Optimization::__read(::IceInternal::BasicStream* __is, ::Optimization::OptimizationEnginePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Optimization::OptimizationEngine;
        v->__copyFrom(proxy);
    }
}

void
Tracking::__read(::IceInternal::BasicStream* __is, ::Tracking::TrackingServicePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Tracking::TrackingService;
        v->__copyFrom(proxy);
    }
}

CustomerRelationsManagement::RecordNotFound::RecordNotFound(::Ice::Int __ice_id, const ::std::string& __ice_name) :
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    UserException(),
#else
    ::Ice::UserException(),
#endif
    id(__ice_id),
    name(__ice_name)
{
}

CustomerRelationsManagement::RecordNotFound::~RecordNotFound() throw()
{
}

static const char* __CustomerRelationsManagement__RecordNotFound_name = "CustomerRelationsManagement::RecordNotFound";

::std::string
CustomerRelationsManagement::RecordNotFound::ice_name() const
{
    return __CustomerRelationsManagement__RecordNotFound_name;
}

::Ice::Exception*
CustomerRelationsManagement::RecordNotFound::ice_clone() const
{
    return new RecordNotFound(*this);
}

void
CustomerRelationsManagement::RecordNotFound::ice_throw() const
{
    throw *this;
}

void
CustomerRelationsManagement::RecordNotFound::__write(::IceInternal::BasicStream* __os) const
{
    __os->write(::std::string("::CustomerRelationsManagement::RecordNotFound"), false);
    __os->startWriteSlice();
    __os->write(id);
    __os->write(name);
    __os->endWriteSlice();
}

void
CustomerRelationsManagement::RecordNotFound::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->read(myId, false);
    }
    __is->startReadSlice();
    __is->read(id);
    __is->read(name);
    __is->endReadSlice();
}

void
CustomerRelationsManagement::RecordNotFound::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "exception CustomerRelationsManagement::RecordNotFound was not generated with stream support";
    throw ex;
}

void
CustomerRelationsManagement::RecordNotFound::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "exception CustomerRelationsManagement::RecordNotFound was not generated with stream support";
    throw ex;
}

struct __F__CustomerRelationsManagement__RecordNotFound : public ::IceInternal::UserExceptionFactory
{
    virtual void
    createAndThrow()
    {
        throw ::CustomerRelationsManagement::RecordNotFound();
    }
};

static ::IceInternal::UserExceptionFactoryPtr __F__CustomerRelationsManagement__RecordNotFound__Ptr = new __F__CustomerRelationsManagement__RecordNotFound;

const ::IceInternal::UserExceptionFactoryPtr&
CustomerRelationsManagement::RecordNotFound::ice_factory()
{
    return __F__CustomerRelationsManagement__RecordNotFound__Ptr;
}

class __F__CustomerRelationsManagement__RecordNotFound__Init
{
public:

    __F__CustomerRelationsManagement__RecordNotFound__Init()
    {
        ::IceInternal::factoryTable->addExceptionFactory("::CustomerRelationsManagement::RecordNotFound", ::CustomerRelationsManagement::RecordNotFound::ice_factory());
    }

    ~__F__CustomerRelationsManagement__RecordNotFound__Init()
    {
        ::IceInternal::factoryTable->removeExceptionFactory("::CustomerRelationsManagement::RecordNotFound");
    }
};

static __F__CustomerRelationsManagement__RecordNotFound__Init __F__CustomerRelationsManagement__RecordNotFound__i;

#ifdef __APPLE__
extern "C" { void __F__CustomerRelationsManagement__RecordNotFound__initializer() {} }
#endif

CustomerRelationsManagement::DBError::DBError(::Ice::Int __ice_errorCode, const ::std::string& __ice_errorText) :
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    UserException(),
#else
    ::Ice::UserException(),
#endif
    errorCode(__ice_errorCode),
    errorText(__ice_errorText)
{
}

CustomerRelationsManagement::DBError::~DBError() throw()
{
}

static const char* __CustomerRelationsManagement__DBError_name = "CustomerRelationsManagement::DBError";

::std::string
CustomerRelationsManagement::DBError::ice_name() const
{
    return __CustomerRelationsManagement__DBError_name;
}

::Ice::Exception*
CustomerRelationsManagement::DBError::ice_clone() const
{
    return new DBError(*this);
}

void
CustomerRelationsManagement::DBError::ice_throw() const
{
    throw *this;
}

void
CustomerRelationsManagement::DBError::__write(::IceInternal::BasicStream* __os) const
{
    __os->write(::std::string("::CustomerRelationsManagement::DBError"), false);
    __os->startWriteSlice();
    __os->write(errorCode);
    __os->write(errorText);
    __os->endWriteSlice();
}

void
CustomerRelationsManagement::DBError::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->read(myId, false);
    }
    __is->startReadSlice();
    __is->read(errorCode);
    __is->read(errorText);
    __is->endReadSlice();
}

void
CustomerRelationsManagement::DBError::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "exception CustomerRelationsManagement::DBError was not generated with stream support";
    throw ex;
}

void
CustomerRelationsManagement::DBError::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "exception CustomerRelationsManagement::DBError was not generated with stream support";
    throw ex;
}

struct __F__CustomerRelationsManagement__DBError : public ::IceInternal::UserExceptionFactory
{
    virtual void
    createAndThrow()
    {
        throw ::CustomerRelationsManagement::DBError();
    }
};

static ::IceInternal::UserExceptionFactoryPtr __F__CustomerRelationsManagement__DBError__Ptr = new __F__CustomerRelationsManagement__DBError;

const ::IceInternal::UserExceptionFactoryPtr&
CustomerRelationsManagement::DBError::ice_factory()
{
    return __F__CustomerRelationsManagement__DBError__Ptr;
}

class __F__CustomerRelationsManagement__DBError__Init
{
public:

    __F__CustomerRelationsManagement__DBError__Init()
    {
        ::IceInternal::factoryTable->addExceptionFactory("::CustomerRelationsManagement::DBError", ::CustomerRelationsManagement::DBError::ice_factory());
    }

    ~__F__CustomerRelationsManagement__DBError__Init()
    {
        ::IceInternal::factoryTable->removeExceptionFactory("::CustomerRelationsManagement::DBError");
    }
};

static __F__CustomerRelationsManagement__DBError__Init __F__CustomerRelationsManagement__DBError__i;

#ifdef __APPLE__
extern "C" { void __F__CustomerRelationsManagement__DBError__initializer() {} }
#endif

CustomerRelationsManagement::RecordNotCommitted::RecordNotCommitted(::Ice::Byte __ice_zero) :
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    UserException(),
#else
    ::Ice::UserException(),
#endif
    zero(__ice_zero)
{
}

CustomerRelationsManagement::RecordNotCommitted::~RecordNotCommitted() throw()
{
}

static const char* __CustomerRelationsManagement__RecordNotCommitted_name = "CustomerRelationsManagement::RecordNotCommitted";

::std::string
CustomerRelationsManagement::RecordNotCommitted::ice_name() const
{
    return __CustomerRelationsManagement__RecordNotCommitted_name;
}

::Ice::Exception*
CustomerRelationsManagement::RecordNotCommitted::ice_clone() const
{
    return new RecordNotCommitted(*this);
}

void
CustomerRelationsManagement::RecordNotCommitted::ice_throw() const
{
    throw *this;
}

void
CustomerRelationsManagement::RecordNotCommitted::__write(::IceInternal::BasicStream* __os) const
{
    __os->write(::std::string("::CustomerRelationsManagement::RecordNotCommitted"), false);
    __os->startWriteSlice();
    __os->write(zero);
    __os->endWriteSlice();
}

void
CustomerRelationsManagement::RecordNotCommitted::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->read(myId, false);
    }
    __is->startReadSlice();
    __is->read(zero);
    __is->endReadSlice();
}

void
CustomerRelationsManagement::RecordNotCommitted::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "exception CustomerRelationsManagement::RecordNotCommitted was not generated with stream support";
    throw ex;
}

void
CustomerRelationsManagement::RecordNotCommitted::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "exception CustomerRelationsManagement::RecordNotCommitted was not generated with stream support";
    throw ex;
}

struct __F__CustomerRelationsManagement__RecordNotCommitted : public ::IceInternal::UserExceptionFactory
{
    virtual void
    createAndThrow()
    {
        throw ::CustomerRelationsManagement::RecordNotCommitted();
    }
};

static ::IceInternal::UserExceptionFactoryPtr __F__CustomerRelationsManagement__RecordNotCommitted__Ptr = new __F__CustomerRelationsManagement__RecordNotCommitted;

const ::IceInternal::UserExceptionFactoryPtr&
CustomerRelationsManagement::RecordNotCommitted::ice_factory()
{
    return __F__CustomerRelationsManagement__RecordNotCommitted__Ptr;
}

class __F__CustomerRelationsManagement__RecordNotCommitted__Init
{
public:

    __F__CustomerRelationsManagement__RecordNotCommitted__Init()
    {
        ::IceInternal::factoryTable->addExceptionFactory("::CustomerRelationsManagement::RecordNotCommitted", ::CustomerRelationsManagement::RecordNotCommitted::ice_factory());
    }

    ~__F__CustomerRelationsManagement__RecordNotCommitted__Init()
    {
        ::IceInternal::factoryTable->removeExceptionFactory("::CustomerRelationsManagement::RecordNotCommitted");
    }
};

static __F__CustomerRelationsManagement__RecordNotCommitted__Init __F__CustomerRelationsManagement__RecordNotCommitted__i;

#ifdef __APPLE__
extern "C" { void __F__CustomerRelationsManagement__RecordNotCommitted__initializer() {} }
#endif

bool
CustomerRelationsManagement::datetime::operator==(const datetime& __rhs) const
{
    if(this == &__rhs)
    {
        return true;
    }
    if(hour != __rhs.hour)
    {
        return false;
    }
    if(minute != __rhs.minute)
    {
        return false;
    }
    if(second != __rhs.second)
    {
        return false;
    }
    if(day != __rhs.day)
    {
        return false;
    }
    if(month != __rhs.month)
    {
        return false;
    }
    if(year != __rhs.year)
    {
        return false;
    }
    return true;
}

bool
CustomerRelationsManagement::datetime::operator<(const datetime& __rhs) const
{
    if(this == &__rhs)
    {
        return false;
    }
    if(hour < __rhs.hour)
    {
        return true;
    }
    else if(__rhs.hour < hour)
    {
        return false;
    }
    if(minute < __rhs.minute)
    {
        return true;
    }
    else if(__rhs.minute < minute)
    {
        return false;
    }
    if(second < __rhs.second)
    {
        return true;
    }
    else if(__rhs.second < second)
    {
        return false;
    }
    if(day < __rhs.day)
    {
        return true;
    }
    else if(__rhs.day < day)
    {
        return false;
    }
    if(month < __rhs.month)
    {
        return true;
    }
    else if(__rhs.month < month)
    {
        return false;
    }
    if(year < __rhs.year)
    {
        return true;
    }
    else if(__rhs.year < year)
    {
        return false;
    }
    return false;
}

void
CustomerRelationsManagement::datetime::__write(::IceInternal::BasicStream* __os) const
{
    __os->write(hour);
    __os->write(minute);
    __os->write(second);
    __os->write(day);
    __os->write(month);
    __os->write(year);
}

void
CustomerRelationsManagement::datetime::__read(::IceInternal::BasicStream* __is)
{
    __is->read(hour);
    __is->read(minute);
    __is->read(second);
    __is->read(day);
    __is->read(month);
    __is->read(year);
}

void
CustomerRelationsManagement::__write(::IceInternal::BasicStream* __os, ::CustomerRelationsManagement::OrderStatus v)
{
    __os->write(static_cast< ::Ice::Byte>(v), 2);
}

void
CustomerRelationsManagement::__read(::IceInternal::BasicStream* __is, ::CustomerRelationsManagement::OrderStatus& v)
{
    ::Ice::Byte val;
    __is->read(val, 2);
    v = static_cast< ::CustomerRelationsManagement::OrderStatus>(val);
}

void
CustomerRelationsManagement::__writeOrderList(::IceInternal::BasicStream* __os, const ::CustomerRelationsManagement::orderPrx* begin, const ::CustomerRelationsManagement::orderPrx* end)
{
    ::Ice::Int size = static_cast< ::Ice::Int>(end - begin);
    __os->writeSize(size);
    for(int i = 0; i < size; ++i)
    {
        __os->write(::Ice::ObjectPrx(::IceInternal::upCast(begin[i].get())));
    }
}

void
CustomerRelationsManagement::__readOrderList(::IceInternal::BasicStream* __is, ::CustomerRelationsManagement::OrderList& v)
{
    ::Ice::Int sz;
    __is->readSize(sz);
    __is->startSeq(sz, 2);
    v.resize(sz);
    for(int i = 0; i < sz; ++i)
    {
        ::CustomerRelationsManagement::__read(__is, v[i]);
        __is->checkSeq();
        __is->endElement();
    }
    __is->endSeq(sz);
}

Optimization::OptimizationEngineBusy::OptimizationEngineBusy(::Ice::Byte __ice_zero) :
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    UserException(),
#else
    ::Ice::UserException(),
#endif
    zero(__ice_zero)
{
}

Optimization::OptimizationEngineBusy::~OptimizationEngineBusy() throw()
{
}

static const char* __Optimization__OptimizationEngineBusy_name = "Optimization::OptimizationEngineBusy";

::std::string
Optimization::OptimizationEngineBusy::ice_name() const
{
    return __Optimization__OptimizationEngineBusy_name;
}

::Ice::Exception*
Optimization::OptimizationEngineBusy::ice_clone() const
{
    return new OptimizationEngineBusy(*this);
}

void
Optimization::OptimizationEngineBusy::ice_throw() const
{
    throw *this;
}

void
Optimization::OptimizationEngineBusy::__write(::IceInternal::BasicStream* __os) const
{
    __os->write(::std::string("::Optimization::OptimizationEngineBusy"), false);
    __os->startWriteSlice();
    __os->write(zero);
    __os->endWriteSlice();
}

void
Optimization::OptimizationEngineBusy::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->read(myId, false);
    }
    __is->startReadSlice();
    __is->read(zero);
    __is->endReadSlice();
}

void
Optimization::OptimizationEngineBusy::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "exception Optimization::OptimizationEngineBusy was not generated with stream support";
    throw ex;
}

void
Optimization::OptimizationEngineBusy::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "exception Optimization::OptimizationEngineBusy was not generated with stream support";
    throw ex;
}

struct __F__Optimization__OptimizationEngineBusy : public ::IceInternal::UserExceptionFactory
{
    virtual void
    createAndThrow()
    {
        throw ::Optimization::OptimizationEngineBusy();
    }
};

static ::IceInternal::UserExceptionFactoryPtr __F__Optimization__OptimizationEngineBusy__Ptr = new __F__Optimization__OptimizationEngineBusy;

const ::IceInternal::UserExceptionFactoryPtr&
Optimization::OptimizationEngineBusy::ice_factory()
{
    return __F__Optimization__OptimizationEngineBusy__Ptr;
}

class __F__Optimization__OptimizationEngineBusy__Init
{
public:

    __F__Optimization__OptimizationEngineBusy__Init()
    {
        ::IceInternal::factoryTable->addExceptionFactory("::Optimization::OptimizationEngineBusy", ::Optimization::OptimizationEngineBusy::ice_factory());
    }

    ~__F__Optimization__OptimizationEngineBusy__Init()
    {
        ::IceInternal::factoryTable->removeExceptionFactory("::Optimization::OptimizationEngineBusy");
    }
};

static __F__Optimization__OptimizationEngineBusy__Init __F__Optimization__OptimizationEngineBusy__i;

#ifdef __APPLE__
extern "C" { void __F__Optimization__OptimizationEngineBusy__initializer() {} }
#endif

bool
Tracking::datetime::operator==(const datetime& __rhs) const
{
    if(this == &__rhs)
    {
        return true;
    }
    if(hour != __rhs.hour)
    {
        return false;
    }
    if(minute != __rhs.minute)
    {
        return false;
    }
    if(second != __rhs.second)
    {
        return false;
    }
    if(day != __rhs.day)
    {
        return false;
    }
    if(month != __rhs.month)
    {
        return false;
    }
    if(year != __rhs.year)
    {
        return false;
    }
    return true;
}

bool
Tracking::datetime::operator<(const datetime& __rhs) const
{
    if(this == &__rhs)
    {
        return false;
    }
    if(hour < __rhs.hour)
    {
        return true;
    }
    else if(__rhs.hour < hour)
    {
        return false;
    }
    if(minute < __rhs.minute)
    {
        return true;
    }
    else if(__rhs.minute < minute)
    {
        return false;
    }
    if(second < __rhs.second)
    {
        return true;
    }
    else if(__rhs.second < second)
    {
        return false;
    }
    if(day < __rhs.day)
    {
        return true;
    }
    else if(__rhs.day < day)
    {
        return false;
    }
    if(month < __rhs.month)
    {
        return true;
    }
    else if(__rhs.month < month)
    {
        return false;
    }
    if(year < __rhs.year)
    {
        return true;
    }
    else if(__rhs.year < year)
    {
        return false;
    }
    return false;
}

void
Tracking::datetime::__write(::IceInternal::BasicStream* __os) const
{
    __os->write(hour);
    __os->write(minute);
    __os->write(second);
    __os->write(day);
    __os->write(month);
    __os->write(year);
}

void
Tracking::datetime::__read(::IceInternal::BasicStream* __is)
{
    __is->read(hour);
    __is->read(minute);
    __is->read(second);
    __is->read(day);
    __is->read(month);
    __is->read(year);
}

void
Tracking::__write(::IceInternal::BasicStream* __os, ::Tracking::StopAction v)
{
    __os->write(static_cast< ::Ice::Byte>(v), 2);
}

void
Tracking::__read(::IceInternal::BasicStream* __is, ::Tracking::StopAction& v)
{
    ::Ice::Byte val;
    __is->read(val, 2);
    v = static_cast< ::Tracking::StopAction>(val);
}

bool
Tracking::StopActionData::operator==(const StopActionData& __rhs) const
{
    if(this == &__rhs)
    {
        return true;
    }
    if(type != __rhs.type)
    {
        return false;
    }
    if(orderID != __rhs.orderID)
    {
        return false;
    }
    if(customerID != __rhs.customerID)
    {
        return false;
    }
    if(src != __rhs.src)
    {
        return false;
    }
    if(dst != __rhs.dst)
    {
        return false;
    }
    if(weight != __rhs.weight)
    {
        return false;
    }
    if(Deadline != __rhs.Deadline)
    {
        return false;
    }
    return true;
}

bool
Tracking::StopActionData::operator<(const StopActionData& __rhs) const
{
    if(this == &__rhs)
    {
        return false;
    }
    if(type < __rhs.type)
    {
        return true;
    }
    else if(__rhs.type < type)
    {
        return false;
    }
    if(orderID < __rhs.orderID)
    {
        return true;
    }
    else if(__rhs.orderID < orderID)
    {
        return false;
    }
    if(customerID < __rhs.customerID)
    {
        return true;
    }
    else if(__rhs.customerID < customerID)
    {
        return false;
    }
    if(src < __rhs.src)
    {
        return true;
    }
    else if(__rhs.src < src)
    {
        return false;
    }
    if(dst < __rhs.dst)
    {
        return true;
    }
    else if(__rhs.dst < dst)
    {
        return false;
    }
    if(weight < __rhs.weight)
    {
        return true;
    }
    else if(__rhs.weight < weight)
    {
        return false;
    }
    if(Deadline < __rhs.Deadline)
    {
        return true;
    }
    else if(__rhs.Deadline < Deadline)
    {
        return false;
    }
    return false;
}

void
Tracking::StopActionData::__write(::IceInternal::BasicStream* __os) const
{
    ::Tracking::__write(__os, type);
    __os->write(orderID);
    __os->write(customerID);
    __os->write(src);
    __os->write(dst);
    __os->write(weight);
    Deadline.__write(__os);
}

void
Tracking::StopActionData::__read(::IceInternal::BasicStream* __is)
{
    ::Tracking::__read(__is, type);
    __is->read(orderID);
    __is->read(customerID);
    __is->read(src);
    __is->read(dst);
    __is->read(weight);
    Deadline.__read(__is);
}

void
Tracking::__writestopactionlist(::IceInternal::BasicStream* __os, const ::Tracking::StopActionData* begin, const ::Tracking::StopActionData* end)
{
    ::Ice::Int size = static_cast< ::Ice::Int>(end - begin);
    __os->writeSize(size);
    for(int i = 0; i < size; ++i)
    {
        begin[i].__write(__os);
    }
}

void
Tracking::__readstopactionlist(::IceInternal::BasicStream* __is, ::Tracking::stopactionlist& v)
{
    ::Ice::Int sz;
    __is->readSize(sz);
    __is->startSeq(sz, 22);
    v.resize(sz);
    for(int i = 0; i < sz; ++i)
    {
        v[i].__read(__is);
        __is->checkSeq();
        __is->endElement();
    }
    __is->endSeq(sz);
}

bool
Tracking::StopData::operator==(const StopData& __rhs) const
{
    if(this == &__rhs)
    {
        return true;
    }
    if(location != __rhs.location)
    {
        return false;
    }
    if(actions != __rhs.actions)
    {
        return false;
    }
    return true;
}

bool
Tracking::StopData::operator<(const StopData& __rhs) const
{
    if(this == &__rhs)
    {
        return false;
    }
    if(location < __rhs.location)
    {
        return true;
    }
    else if(__rhs.location < location)
    {
        return false;
    }
    if(actions < __rhs.actions)
    {
        return true;
    }
    else if(__rhs.actions < actions)
    {
        return false;
    }
    return false;
}

void
Tracking::StopData::__write(::IceInternal::BasicStream* __os) const
{
    __os->write(location);
    if(actions.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        ::Tracking::__writestopactionlist(__os, &actions[0], &actions[0] + actions.size());
    }
}

void
Tracking::StopData::__read(::IceInternal::BasicStream* __is)
{
    __is->read(location);
    ::Tracking::__readstopactionlist(__is, actions);
}

void
Tracking::__writestoplist(::IceInternal::BasicStream* __os, const ::Tracking::StopData* begin, const ::Tracking::StopData* end)
{
    ::Ice::Int size = static_cast< ::Ice::Int>(end - begin);
    __os->writeSize(size);
    for(int i = 0; i < size; ++i)
    {
        begin[i].__write(__os);
    }
}

void
Tracking::__readstoplist(::IceInternal::BasicStream* __is, ::Tracking::stoplist& v)
{
    ::Ice::Int sz;
    __is->readSize(sz);
    __is->startSeq(sz, 2);
    v.resize(sz);
    for(int i = 0; i < sz; ++i)
    {
        v[i].__read(__is);
        __is->checkSeq();
        __is->endElement();
    }
    __is->endSeq(sz);
}

bool
Tracking::TruckData::operator==(const TruckData& __rhs) const
{
    if(this == &__rhs)
    {
        return true;
    }
    if(id != __rhs.id)
    {
        return false;
    }
    if(capacity != __rhs.capacity)
    {
        return false;
    }
    if(stops != __rhs.stops)
    {
        return false;
    }
    return true;
}

bool
Tracking::TruckData::operator<(const TruckData& __rhs) const
{
    if(this == &__rhs)
    {
        return false;
    }
    if(id < __rhs.id)
    {
        return true;
    }
    else if(__rhs.id < id)
    {
        return false;
    }
    if(capacity < __rhs.capacity)
    {
        return true;
    }
    else if(__rhs.capacity < capacity)
    {
        return false;
    }
    if(stops < __rhs.stops)
    {
        return true;
    }
    else if(__rhs.stops < stops)
    {
        return false;
    }
    return false;
}

void
Tracking::TruckData::__write(::IceInternal::BasicStream* __os) const
{
    __os->write(id);
    __os->write(capacity);
    if(stops.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        ::Tracking::__writestoplist(__os, &stops[0], &stops[0] + stops.size());
    }
}

void
Tracking::TruckData::__read(::IceInternal::BasicStream* __is)
{
    __is->read(id);
    __is->read(capacity);
    ::Tracking::__readstoplist(__is, stops);
}

void
Tracking::__writetrucklist(::IceInternal::BasicStream* __os, const ::Tracking::TruckData* begin, const ::Tracking::TruckData* end)
{
    ::Ice::Int size = static_cast< ::Ice::Int>(end - begin);
    __os->writeSize(size);
    for(int i = 0; i < size; ++i)
    {
        begin[i].__write(__os);
    }
}

void
Tracking::__readtrucklist(::IceInternal::BasicStream* __is, ::Tracking::trucklist& v)
{
    ::Ice::Int sz;
    __is->readSize(sz);
    __is->startSeq(sz, 6);
    v.resize(sz);
    for(int i = 0; i < sz; ++i)
    {
        v[i].__read(__is);
        __is->checkSeq();
        __is->endElement();
    }
    __is->endSeq(sz);
}

bool
Tracking::RouteData::operator==(const RouteData& __rhs) const
{
    if(this == &__rhs)
    {
        return true;
    }
    if(Trucks != __rhs.Trucks)
    {
        return false;
    }
    return true;
}

bool
Tracking::RouteData::operator<(const RouteData& __rhs) const
{
    if(this == &__rhs)
    {
        return false;
    }
    if(Trucks < __rhs.Trucks)
    {
        return true;
    }
    else if(__rhs.Trucks < Trucks)
    {
        return false;
    }
    return false;
}

void
Tracking::RouteData::__write(::IceInternal::BasicStream* __os) const
{
    if(Trucks.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        ::Tracking::__writetrucklist(__os, &Trucks[0], &Trucks[0] + Trucks.size());
    }
}

void
Tracking::RouteData::__read(::IceInternal::BasicStream* __is)
{
    ::Tracking::__readtrucklist(__is, Trucks);
}

::Ice::Int
IceProxy::CustomerRelationsManagement::customer::getId(const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __checkTwowayOnly(__CustomerRelationsManagement__customer__getId_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::CustomerRelationsManagement::customer* __del = dynamic_cast< ::IceDelegate::CustomerRelationsManagement::customer*>(__delBase.get());
            return __del->getId(__ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

void
IceProxy::CustomerRelationsManagement::customer::save(const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __checkTwowayOnly(__CustomerRelationsManagement__customer__save_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::CustomerRelationsManagement::customer* __del = dynamic_cast< ::IceDelegate::CustomerRelationsManagement::customer*>(__delBase.get());
            __del->save(__ctx);
            return;
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

void
IceProxy::CustomerRelationsManagement::customer::_cpp_delete(const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __checkTwowayOnly(__CustomerRelationsManagement__customer__delete_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::CustomerRelationsManagement::customer* __del = dynamic_cast< ::IceDelegate::CustomerRelationsManagement::customer*>(__delBase.get());
            __del->_cpp_delete(__ctx);
            return;
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

::std::string
IceProxy::CustomerRelationsManagement::customer::getName(const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __checkTwowayOnly(__CustomerRelationsManagement__customer__getName_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::CustomerRelationsManagement::customer* __del = dynamic_cast< ::IceDelegate::CustomerRelationsManagement::customer*>(__delBase.get());
            return __del->getName(__ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

void
IceProxy::CustomerRelationsManagement::customer::setName(const ::std::string& name, const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __delBase = __getDelegate(false);
            ::IceDelegate::CustomerRelationsManagement::customer* __del = dynamic_cast< ::IceDelegate::CustomerRelationsManagement::customer*>(__delBase.get());
            __del->setName(name, __ctx);
            return;
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

const ::std::string&
IceProxy::CustomerRelationsManagement::customer::ice_staticId()
{
    return ::CustomerRelationsManagement::customer::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::CustomerRelationsManagement::customer::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::CustomerRelationsManagement::customer);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::CustomerRelationsManagement::customer::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::CustomerRelationsManagement::customer);
}

::IceProxy::Ice::Object*
IceProxy::CustomerRelationsManagement::customer::__newInstance() const
{
    return new customer;
}

::Ice::Int
IceProxy::CustomerRelationsManagement::order::getId(const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __checkTwowayOnly(__CustomerRelationsManagement__order__getId_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::CustomerRelationsManagement::order* __del = dynamic_cast< ::IceDelegate::CustomerRelationsManagement::order*>(__delBase.get());
            return __del->getId(__ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

void
IceProxy::CustomerRelationsManagement::order::save(const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __checkTwowayOnly(__CustomerRelationsManagement__order__save_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::CustomerRelationsManagement::order* __del = dynamic_cast< ::IceDelegate::CustomerRelationsManagement::order*>(__delBase.get());
            __del->save(__ctx);
            return;
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

void
IceProxy::CustomerRelationsManagement::order::_cpp_delete(const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __checkTwowayOnly(__CustomerRelationsManagement__order__delete_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::CustomerRelationsManagement::order* __del = dynamic_cast< ::IceDelegate::CustomerRelationsManagement::order*>(__delBase.get());
            __del->_cpp_delete(__ctx);
            return;
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

::Ice::Int
IceProxy::CustomerRelationsManagement::order::getCustomer(const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __checkTwowayOnly(__CustomerRelationsManagement__order__getCustomer_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::CustomerRelationsManagement::order* __del = dynamic_cast< ::IceDelegate::CustomerRelationsManagement::order*>(__delBase.get());
            return __del->getCustomer(__ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

void
IceProxy::CustomerRelationsManagement::order::setCustomer(::Ice::Int CustomerId, const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __delBase = __getDelegate(false);
            ::IceDelegate::CustomerRelationsManagement::order* __del = dynamic_cast< ::IceDelegate::CustomerRelationsManagement::order*>(__delBase.get());
            __del->setCustomer(CustomerId, __ctx);
            return;
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

::std::string
IceProxy::CustomerRelationsManagement::order::getSrc(const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __checkTwowayOnly(__CustomerRelationsManagement__order__getSrc_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::CustomerRelationsManagement::order* __del = dynamic_cast< ::IceDelegate::CustomerRelationsManagement::order*>(__delBase.get());
            return __del->getSrc(__ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

::std::string
IceProxy::CustomerRelationsManagement::order::getDst(const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __checkTwowayOnly(__CustomerRelationsManagement__order__getDst_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::CustomerRelationsManagement::order* __del = dynamic_cast< ::IceDelegate::CustomerRelationsManagement::order*>(__delBase.get());
            return __del->getDst(__ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

void
IceProxy::CustomerRelationsManagement::order::setSrc(const ::std::string& src, const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __delBase = __getDelegate(false);
            ::IceDelegate::CustomerRelationsManagement::order* __del = dynamic_cast< ::IceDelegate::CustomerRelationsManagement::order*>(__delBase.get());
            __del->setSrc(src, __ctx);
            return;
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

void
IceProxy::CustomerRelationsManagement::order::setDst(const ::std::string& dst, const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __delBase = __getDelegate(false);
            ::IceDelegate::CustomerRelationsManagement::order* __del = dynamic_cast< ::IceDelegate::CustomerRelationsManagement::order*>(__delBase.get());
            __del->setDst(dst, __ctx);
            return;
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

::Ice::Float
IceProxy::CustomerRelationsManagement::order::getWeight(const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __checkTwowayOnly(__CustomerRelationsManagement__order__getWeight_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::CustomerRelationsManagement::order* __del = dynamic_cast< ::IceDelegate::CustomerRelationsManagement::order*>(__delBase.get());
            return __del->getWeight(__ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

void
IceProxy::CustomerRelationsManagement::order::setWeight(::Ice::Float weight, const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __delBase = __getDelegate(false);
            ::IceDelegate::CustomerRelationsManagement::order* __del = dynamic_cast< ::IceDelegate::CustomerRelationsManagement::order*>(__delBase.get());
            __del->setWeight(weight, __ctx);
            return;
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

::CustomerRelationsManagement::datetime
IceProxy::CustomerRelationsManagement::order::getDeadline(const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __checkTwowayOnly(__CustomerRelationsManagement__order__getDeadline_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::CustomerRelationsManagement::order* __del = dynamic_cast< ::IceDelegate::CustomerRelationsManagement::order*>(__delBase.get());
            return __del->getDeadline(__ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

void
IceProxy::CustomerRelationsManagement::order::setDeadline(const ::CustomerRelationsManagement::datetime& deadline, const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __delBase = __getDelegate(false);
            ::IceDelegate::CustomerRelationsManagement::order* __del = dynamic_cast< ::IceDelegate::CustomerRelationsManagement::order*>(__delBase.get());
            __del->setDeadline(deadline, __ctx);
            return;
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

::CustomerRelationsManagement::OrderStatus
IceProxy::CustomerRelationsManagement::order::getStatus(const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __checkTwowayOnly(__CustomerRelationsManagement__order__getStatus_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::CustomerRelationsManagement::order* __del = dynamic_cast< ::IceDelegate::CustomerRelationsManagement::order*>(__delBase.get());
            return __del->getStatus(__ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

void
IceProxy::CustomerRelationsManagement::order::setStatus(::CustomerRelationsManagement::OrderStatus status, const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __delBase = __getDelegate(false);
            ::IceDelegate::CustomerRelationsManagement::order* __del = dynamic_cast< ::IceDelegate::CustomerRelationsManagement::order*>(__delBase.get());
            __del->setStatus(status, __ctx);
            return;
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

const ::std::string&
IceProxy::CustomerRelationsManagement::order::ice_staticId()
{
    return ::CustomerRelationsManagement::order::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::CustomerRelationsManagement::order::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::CustomerRelationsManagement::order);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::CustomerRelationsManagement::order::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::CustomerRelationsManagement::order);
}

::IceProxy::Ice::Object*
IceProxy::CustomerRelationsManagement::order::__newInstance() const
{
    return new order;
}

::CustomerRelationsManagement::customerPrx
IceProxy::CustomerRelationsManagement::CRM::CreateCustomer(const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __checkTwowayOnly(__CustomerRelationsManagement__CRM__CreateCustomer_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::CustomerRelationsManagement::CRM* __del = dynamic_cast< ::IceDelegate::CustomerRelationsManagement::CRM*>(__delBase.get());
            return __del->CreateCustomer(__ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

::CustomerRelationsManagement::customerPrx
IceProxy::CustomerRelationsManagement::CRM::LoadCustomerByName(const ::std::string& CustName, const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __checkTwowayOnly(__CustomerRelationsManagement__CRM__LoadCustomerByName_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::CustomerRelationsManagement::CRM* __del = dynamic_cast< ::IceDelegate::CustomerRelationsManagement::CRM*>(__delBase.get());
            return __del->LoadCustomerByName(CustName, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

::CustomerRelationsManagement::customerPrx
IceProxy::CustomerRelationsManagement::CRM::LoadCustomerById(::Ice::Int CustId, const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __checkTwowayOnly(__CustomerRelationsManagement__CRM__LoadCustomerById_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::CustomerRelationsManagement::CRM* __del = dynamic_cast< ::IceDelegate::CustomerRelationsManagement::CRM*>(__delBase.get());
            return __del->LoadCustomerById(CustId, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

::CustomerRelationsManagement::orderPrx
IceProxy::CustomerRelationsManagement::CRM::CreateOrder(const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __checkTwowayOnly(__CustomerRelationsManagement__CRM__CreateOrder_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::CustomerRelationsManagement::CRM* __del = dynamic_cast< ::IceDelegate::CustomerRelationsManagement::CRM*>(__delBase.get());
            return __del->CreateOrder(__ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

::CustomerRelationsManagement::orderPrx
IceProxy::CustomerRelationsManagement::CRM::LoadOrderById(::Ice::Int OrderId, const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __checkTwowayOnly(__CustomerRelationsManagement__CRM__LoadOrderById_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::CustomerRelationsManagement::CRM* __del = dynamic_cast< ::IceDelegate::CustomerRelationsManagement::CRM*>(__delBase.get());
            return __del->LoadOrderById(OrderId, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

::CustomerRelationsManagement::OrderList
IceProxy::CustomerRelationsManagement::CRM::LoadOrderByCustomer(::Ice::Int CustId, const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __checkTwowayOnly(__CustomerRelationsManagement__CRM__LoadOrderByCustomer_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::CustomerRelationsManagement::CRM* __del = dynamic_cast< ::IceDelegate::CustomerRelationsManagement::CRM*>(__delBase.get());
            return __del->LoadOrderByCustomer(CustId, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

::CustomerRelationsManagement::OrderList
IceProxy::CustomerRelationsManagement::CRM::LoadNewOrders(const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __checkTwowayOnly(__CustomerRelationsManagement__CRM__LoadNewOrders_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::CustomerRelationsManagement::CRM* __del = dynamic_cast< ::IceDelegate::CustomerRelationsManagement::CRM*>(__delBase.get());
            return __del->LoadNewOrders(__ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

const ::std::string&
IceProxy::CustomerRelationsManagement::CRM::ice_staticId()
{
    return ::CustomerRelationsManagement::CRM::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::CustomerRelationsManagement::CRM::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::CustomerRelationsManagement::CRM);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::CustomerRelationsManagement::CRM::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::CustomerRelationsManagement::CRM);
}

::IceProxy::Ice::Object*
IceProxy::CustomerRelationsManagement::CRM::__newInstance() const
{
    return new CRM;
}

void
IceProxy::Optimization::OptimizationEngine::runTest(const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __checkTwowayOnly(__Optimization__OptimizationEngine__runTest_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::Optimization::OptimizationEngine* __del = dynamic_cast< ::IceDelegate::Optimization::OptimizationEngine*>(__delBase.get());
            __del->runTest(__ctx);
            return;
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

const ::std::string&
IceProxy::Optimization::OptimizationEngine::ice_staticId()
{
    return ::Optimization::OptimizationEngine::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::Optimization::OptimizationEngine::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Optimization::OptimizationEngine);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::Optimization::OptimizationEngine::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Optimization::OptimizationEngine);
}

::IceProxy::Ice::Object*
IceProxy::Optimization::OptimizationEngine::__newInstance() const
{
    return new OptimizationEngine;
}

::Tracking::RouteData
IceProxy::Tracking::TrackingService::getAllData(const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __checkTwowayOnly(__Tracking__TrackingService__getAllData_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::Tracking::TrackingService* __del = dynamic_cast< ::IceDelegate::Tracking::TrackingService*>(__delBase.get());
            return __del->getAllData(__ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

void
IceProxy::Tracking::TrackingService::postNewRoutes(const ::Tracking::RouteData& nrd, const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __delBase = __getDelegate(false);
            ::IceDelegate::Tracking::TrackingService* __del = dynamic_cast< ::IceDelegate::Tracking::TrackingService*>(__delBase.get());
            __del->postNewRoutes(nrd, __ctx);
            return;
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

const ::std::string&
IceProxy::Tracking::TrackingService::ice_staticId()
{
    return ::Tracking::TrackingService::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::Tracking::TrackingService::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Tracking::TrackingService);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::Tracking::TrackingService::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Tracking::TrackingService);
}

::IceProxy::Ice::Object*
IceProxy::Tracking::TrackingService::__newInstance() const
{
    return new TrackingService;
}

::Ice::Int
IceDelegateM::CustomerRelationsManagement::customer::getId(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __CustomerRelationsManagement__customer__getId_name, ::Ice::Normal, __context);
    bool __ok = __og.invoke();
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::CustomerRelationsManagement::RecordNotCommitted&)
            {
                throw;
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::Ice::Int __ret;
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        __is->read(__ret);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

void
IceDelegateM::CustomerRelationsManagement::customer::save(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __CustomerRelationsManagement__customer__save_name, ::Ice::Normal, __context);
    bool __ok = __og.invoke();
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::CustomerRelationsManagement::DBError&)
            {
                throw;
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        __is->endReadEncaps();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

void
IceDelegateM::CustomerRelationsManagement::customer::_cpp_delete(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __CustomerRelationsManagement__customer__delete_name, ::Ice::Normal, __context);
    bool __ok = __og.invoke();
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::CustomerRelationsManagement::DBError&)
            {
                throw;
            }
            catch(const ::CustomerRelationsManagement::RecordNotCommitted&)
            {
                throw;
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        __is->endReadEncaps();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

::std::string
IceDelegateM::CustomerRelationsManagement::customer::getName(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __CustomerRelationsManagement__customer__getName_name, ::Ice::Normal, __context);
    bool __ok = __og.invoke();
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::std::string __ret;
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        __is->read(__ret);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

void
IceDelegateM::CustomerRelationsManagement::customer::setName(const ::std::string& name, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __CustomerRelationsManagement__customer__setName_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(name);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    if(!__og.is()->b.empty())
    {
        try
        {
            if(!__ok)
            {
                try
                {
                    __og.throwUserException();
                }
                catch(const ::Ice::UserException& __ex)
                {
                    ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                    throw __uue;
                }
            }
            __og.is()->skipEmptyEncaps();
        }
        catch(const ::Ice::LocalException& __ex)
        {
            throw ::IceInternal::LocalExceptionWrapper(__ex, false);
        }
    }
}

::Ice::Int
IceDelegateM::CustomerRelationsManagement::order::getId(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __CustomerRelationsManagement__order__getId_name, ::Ice::Normal, __context);
    bool __ok = __og.invoke();
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::CustomerRelationsManagement::RecordNotCommitted&)
            {
                throw;
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::Ice::Int __ret;
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        __is->read(__ret);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

void
IceDelegateM::CustomerRelationsManagement::order::save(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __CustomerRelationsManagement__order__save_name, ::Ice::Normal, __context);
    bool __ok = __og.invoke();
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::CustomerRelationsManagement::DBError&)
            {
                throw;
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        __is->endReadEncaps();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

void
IceDelegateM::CustomerRelationsManagement::order::_cpp_delete(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __CustomerRelationsManagement__order__delete_name, ::Ice::Normal, __context);
    bool __ok = __og.invoke();
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::CustomerRelationsManagement::DBError&)
            {
                throw;
            }
            catch(const ::CustomerRelationsManagement::RecordNotCommitted&)
            {
                throw;
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        __is->endReadEncaps();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

::Ice::Int
IceDelegateM::CustomerRelationsManagement::order::getCustomer(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __CustomerRelationsManagement__order__getCustomer_name, ::Ice::Normal, __context);
    bool __ok = __og.invoke();
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::Ice::Int __ret;
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        __is->read(__ret);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

void
IceDelegateM::CustomerRelationsManagement::order::setCustomer(::Ice::Int CustomerId, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __CustomerRelationsManagement__order__setCustomer_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(CustomerId);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    if(!__og.is()->b.empty())
    {
        try
        {
            if(!__ok)
            {
                try
                {
                    __og.throwUserException();
                }
                catch(const ::Ice::UserException& __ex)
                {
                    ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                    throw __uue;
                }
            }
            __og.is()->skipEmptyEncaps();
        }
        catch(const ::Ice::LocalException& __ex)
        {
            throw ::IceInternal::LocalExceptionWrapper(__ex, false);
        }
    }
}

::std::string
IceDelegateM::CustomerRelationsManagement::order::getSrc(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __CustomerRelationsManagement__order__getSrc_name, ::Ice::Normal, __context);
    bool __ok = __og.invoke();
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::std::string __ret;
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        __is->read(__ret);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

::std::string
IceDelegateM::CustomerRelationsManagement::order::getDst(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __CustomerRelationsManagement__order__getDst_name, ::Ice::Normal, __context);
    bool __ok = __og.invoke();
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::std::string __ret;
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        __is->read(__ret);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

void
IceDelegateM::CustomerRelationsManagement::order::setSrc(const ::std::string& src, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __CustomerRelationsManagement__order__setSrc_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(src);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    if(!__og.is()->b.empty())
    {
        try
        {
            if(!__ok)
            {
                try
                {
                    __og.throwUserException();
                }
                catch(const ::Ice::UserException& __ex)
                {
                    ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                    throw __uue;
                }
            }
            __og.is()->skipEmptyEncaps();
        }
        catch(const ::Ice::LocalException& __ex)
        {
            throw ::IceInternal::LocalExceptionWrapper(__ex, false);
        }
    }
}

void
IceDelegateM::CustomerRelationsManagement::order::setDst(const ::std::string& dst, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __CustomerRelationsManagement__order__setDst_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(dst);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    if(!__og.is()->b.empty())
    {
        try
        {
            if(!__ok)
            {
                try
                {
                    __og.throwUserException();
                }
                catch(const ::Ice::UserException& __ex)
                {
                    ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                    throw __uue;
                }
            }
            __og.is()->skipEmptyEncaps();
        }
        catch(const ::Ice::LocalException& __ex)
        {
            throw ::IceInternal::LocalExceptionWrapper(__ex, false);
        }
    }
}

::Ice::Float
IceDelegateM::CustomerRelationsManagement::order::getWeight(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __CustomerRelationsManagement__order__getWeight_name, ::Ice::Normal, __context);
    bool __ok = __og.invoke();
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::Ice::Float __ret;
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        __is->read(__ret);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

void
IceDelegateM::CustomerRelationsManagement::order::setWeight(::Ice::Float weight, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __CustomerRelationsManagement__order__setWeight_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(weight);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    if(!__og.is()->b.empty())
    {
        try
        {
            if(!__ok)
            {
                try
                {
                    __og.throwUserException();
                }
                catch(const ::Ice::UserException& __ex)
                {
                    ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                    throw __uue;
                }
            }
            __og.is()->skipEmptyEncaps();
        }
        catch(const ::Ice::LocalException& __ex)
        {
            throw ::IceInternal::LocalExceptionWrapper(__ex, false);
        }
    }
}

::CustomerRelationsManagement::datetime
IceDelegateM::CustomerRelationsManagement::order::getDeadline(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __CustomerRelationsManagement__order__getDeadline_name, ::Ice::Normal, __context);
    bool __ok = __og.invoke();
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::CustomerRelationsManagement::datetime __ret;
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        __ret.__read(__is);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

void
IceDelegateM::CustomerRelationsManagement::order::setDeadline(const ::CustomerRelationsManagement::datetime& deadline, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __CustomerRelationsManagement__order__setDeadline_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        deadline.__write(__os);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    if(!__og.is()->b.empty())
    {
        try
        {
            if(!__ok)
            {
                try
                {
                    __og.throwUserException();
                }
                catch(const ::Ice::UserException& __ex)
                {
                    ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                    throw __uue;
                }
            }
            __og.is()->skipEmptyEncaps();
        }
        catch(const ::Ice::LocalException& __ex)
        {
            throw ::IceInternal::LocalExceptionWrapper(__ex, false);
        }
    }
}

::CustomerRelationsManagement::OrderStatus
IceDelegateM::CustomerRelationsManagement::order::getStatus(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __CustomerRelationsManagement__order__getStatus_name, ::Ice::Normal, __context);
    bool __ok = __og.invoke();
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::CustomerRelationsManagement::OrderStatus __ret;
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        ::CustomerRelationsManagement::__read(__is, __ret);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

void
IceDelegateM::CustomerRelationsManagement::order::setStatus(::CustomerRelationsManagement::OrderStatus status, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __CustomerRelationsManagement__order__setStatus_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        ::CustomerRelationsManagement::__write(__os, status);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    if(!__og.is()->b.empty())
    {
        try
        {
            if(!__ok)
            {
                try
                {
                    __og.throwUserException();
                }
                catch(const ::Ice::UserException& __ex)
                {
                    ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                    throw __uue;
                }
            }
            __og.is()->skipEmptyEncaps();
        }
        catch(const ::Ice::LocalException& __ex)
        {
            throw ::IceInternal::LocalExceptionWrapper(__ex, false);
        }
    }
}

::CustomerRelationsManagement::customerPrx
IceDelegateM::CustomerRelationsManagement::CRM::CreateCustomer(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __CustomerRelationsManagement__CRM__CreateCustomer_name, ::Ice::Normal, __context);
    bool __ok = __og.invoke();
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::CustomerRelationsManagement::customerPrx __ret;
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        ::CustomerRelationsManagement::__read(__is, __ret);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

::CustomerRelationsManagement::customerPrx
IceDelegateM::CustomerRelationsManagement::CRM::LoadCustomerByName(const ::std::string& CustName, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __CustomerRelationsManagement__CRM__LoadCustomerByName_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(CustName);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::CustomerRelationsManagement::DBError&)
            {
                throw;
            }
            catch(const ::CustomerRelationsManagement::RecordNotFound&)
            {
                throw;
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::CustomerRelationsManagement::customerPrx __ret;
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        ::CustomerRelationsManagement::__read(__is, __ret);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

::CustomerRelationsManagement::customerPrx
IceDelegateM::CustomerRelationsManagement::CRM::LoadCustomerById(::Ice::Int CustId, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __CustomerRelationsManagement__CRM__LoadCustomerById_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(CustId);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::CustomerRelationsManagement::DBError&)
            {
                throw;
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::CustomerRelationsManagement::customerPrx __ret;
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        ::CustomerRelationsManagement::__read(__is, __ret);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

::CustomerRelationsManagement::orderPrx
IceDelegateM::CustomerRelationsManagement::CRM::CreateOrder(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __CustomerRelationsManagement__CRM__CreateOrder_name, ::Ice::Normal, __context);
    bool __ok = __og.invoke();
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::CustomerRelationsManagement::orderPrx __ret;
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        ::CustomerRelationsManagement::__read(__is, __ret);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

::CustomerRelationsManagement::orderPrx
IceDelegateM::CustomerRelationsManagement::CRM::LoadOrderById(::Ice::Int OrderId, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __CustomerRelationsManagement__CRM__LoadOrderById_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(OrderId);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::CustomerRelationsManagement::DBError&)
            {
                throw;
            }
            catch(const ::CustomerRelationsManagement::RecordNotFound&)
            {
                throw;
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::CustomerRelationsManagement::orderPrx __ret;
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        ::CustomerRelationsManagement::__read(__is, __ret);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

::CustomerRelationsManagement::OrderList
IceDelegateM::CustomerRelationsManagement::CRM::LoadOrderByCustomer(::Ice::Int CustId, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __CustomerRelationsManagement__CRM__LoadOrderByCustomer_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(CustId);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::CustomerRelationsManagement::DBError&)
            {
                throw;
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::CustomerRelationsManagement::OrderList __ret;
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        ::CustomerRelationsManagement::__readOrderList(__is, __ret);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

::CustomerRelationsManagement::OrderList
IceDelegateM::CustomerRelationsManagement::CRM::LoadNewOrders(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __CustomerRelationsManagement__CRM__LoadNewOrders_name, ::Ice::Normal, __context);
    bool __ok = __og.invoke();
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::CustomerRelationsManagement::DBError&)
            {
                throw;
            }
            catch(const ::CustomerRelationsManagement::RecordNotFound&)
            {
                throw;
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::CustomerRelationsManagement::OrderList __ret;
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        ::CustomerRelationsManagement::__readOrderList(__is, __ret);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

void
IceDelegateM::Optimization::OptimizationEngine::runTest(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Optimization__OptimizationEngine__runTest_name, ::Ice::Normal, __context);
    bool __ok = __og.invoke();
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Optimization::OptimizationEngineBusy&)
            {
                throw;
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        __is->endReadEncaps();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

::Tracking::RouteData
IceDelegateM::Tracking::TrackingService::getAllData(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Tracking__TrackingService__getAllData_name, ::Ice::Normal, __context);
    bool __ok = __og.invoke();
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::Tracking::RouteData __ret;
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        __ret.__read(__is);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

void
IceDelegateM::Tracking::TrackingService::postNewRoutes(const ::Tracking::RouteData& nrd, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Tracking__TrackingService__postNewRoutes_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        nrd.__write(__os);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    if(!__og.is()->b.empty())
    {
        try
        {
            if(!__ok)
            {
                try
                {
                    __og.throwUserException();
                }
                catch(const ::Ice::UserException& __ex)
                {
                    ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                    throw __uue;
                }
            }
            __og.is()->skipEmptyEncaps();
        }
        catch(const ::Ice::LocalException& __ex)
        {
            throw ::IceInternal::LocalExceptionWrapper(__ex, false);
        }
    }
}

::Ice::Int
IceDelegateD::CustomerRelationsManagement::customer::getId(const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::Ice::Int& __result, const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current),
            _result(__result)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::CustomerRelationsManagement::customer* servant = dynamic_cast< ::CustomerRelationsManagement::customer*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            try
            {
                _result = servant->getId(_current);
                return ::Ice::DispatchOK;
            }
            catch(const ::Ice::UserException& __ex)
            {
                setUserException(__ex);
                return ::Ice::DispatchUserException;
            }
        }
        
    private:
        
        ::Ice::Int& _result;
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __CustomerRelationsManagement__customer__getId_name, ::Ice::Normal, __context);
    ::Ice::Int __result;
    try
    {
        _DirectI __direct(__result, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::CustomerRelationsManagement::RecordNotCommitted&)
    {
        throw;
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
    return __result;
}

void
IceDelegateD::CustomerRelationsManagement::customer::save(const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::CustomerRelationsManagement::customer* servant = dynamic_cast< ::CustomerRelationsManagement::customer*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            try
            {
                servant->save(_current);
                return ::Ice::DispatchOK;
            }
            catch(const ::Ice::UserException& __ex)
            {
                setUserException(__ex);
                return ::Ice::DispatchUserException;
            }
        }
        
    private:
        
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __CustomerRelationsManagement__customer__save_name, ::Ice::Normal, __context);
    try
    {
        _DirectI __direct(__current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::CustomerRelationsManagement::DBError&)
    {
        throw;
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
}

void
IceDelegateD::CustomerRelationsManagement::customer::_cpp_delete(const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::CustomerRelationsManagement::customer* servant = dynamic_cast< ::CustomerRelationsManagement::customer*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            try
            {
                servant->_cpp_delete(_current);
                return ::Ice::DispatchOK;
            }
            catch(const ::Ice::UserException& __ex)
            {
                setUserException(__ex);
                return ::Ice::DispatchUserException;
            }
        }
        
    private:
        
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __CustomerRelationsManagement__customer__delete_name, ::Ice::Normal, __context);
    try
    {
        _DirectI __direct(__current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::CustomerRelationsManagement::DBError&)
    {
        throw;
    }
    catch(const ::CustomerRelationsManagement::RecordNotCommitted&)
    {
        throw;
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
}

::std::string
IceDelegateD::CustomerRelationsManagement::customer::getName(const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::std::string& __result, const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current),
            _result(__result)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::CustomerRelationsManagement::customer* servant = dynamic_cast< ::CustomerRelationsManagement::customer*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            _result = servant->getName(_current);
            return ::Ice::DispatchOK;
        }
        
    private:
        
        ::std::string& _result;
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __CustomerRelationsManagement__customer__getName_name, ::Ice::Normal, __context);
    ::std::string __result;
    try
    {
        _DirectI __direct(__result, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
    return __result;
}

void
IceDelegateD::CustomerRelationsManagement::customer::setName(const ::std::string& name, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(const ::std::string& name, const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current),
            _m_name(name)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::CustomerRelationsManagement::customer* servant = dynamic_cast< ::CustomerRelationsManagement::customer*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            servant->setName(_m_name, _current);
            return ::Ice::DispatchOK;
        }
        
    private:
        
        const ::std::string& _m_name;
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __CustomerRelationsManagement__customer__setName_name, ::Ice::Normal, __context);
    try
    {
        _DirectI __direct(name, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
}

::Ice::Int
IceDelegateD::CustomerRelationsManagement::order::getId(const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::Ice::Int& __result, const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current),
            _result(__result)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::CustomerRelationsManagement::order* servant = dynamic_cast< ::CustomerRelationsManagement::order*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            try
            {
                _result = servant->getId(_current);
                return ::Ice::DispatchOK;
            }
            catch(const ::Ice::UserException& __ex)
            {
                setUserException(__ex);
                return ::Ice::DispatchUserException;
            }
        }
        
    private:
        
        ::Ice::Int& _result;
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __CustomerRelationsManagement__order__getId_name, ::Ice::Normal, __context);
    ::Ice::Int __result;
    try
    {
        _DirectI __direct(__result, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::CustomerRelationsManagement::RecordNotCommitted&)
    {
        throw;
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
    return __result;
}

void
IceDelegateD::CustomerRelationsManagement::order::save(const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::CustomerRelationsManagement::order* servant = dynamic_cast< ::CustomerRelationsManagement::order*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            try
            {
                servant->save(_current);
                return ::Ice::DispatchOK;
            }
            catch(const ::Ice::UserException& __ex)
            {
                setUserException(__ex);
                return ::Ice::DispatchUserException;
            }
        }
        
    private:
        
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __CustomerRelationsManagement__order__save_name, ::Ice::Normal, __context);
    try
    {
        _DirectI __direct(__current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::CustomerRelationsManagement::DBError&)
    {
        throw;
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
}

void
IceDelegateD::CustomerRelationsManagement::order::_cpp_delete(const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::CustomerRelationsManagement::order* servant = dynamic_cast< ::CustomerRelationsManagement::order*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            try
            {
                servant->_cpp_delete(_current);
                return ::Ice::DispatchOK;
            }
            catch(const ::Ice::UserException& __ex)
            {
                setUserException(__ex);
                return ::Ice::DispatchUserException;
            }
        }
        
    private:
        
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __CustomerRelationsManagement__order__delete_name, ::Ice::Normal, __context);
    try
    {
        _DirectI __direct(__current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::CustomerRelationsManagement::DBError&)
    {
        throw;
    }
    catch(const ::CustomerRelationsManagement::RecordNotCommitted&)
    {
        throw;
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
}

::Ice::Int
IceDelegateD::CustomerRelationsManagement::order::getCustomer(const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::Ice::Int& __result, const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current),
            _result(__result)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::CustomerRelationsManagement::order* servant = dynamic_cast< ::CustomerRelationsManagement::order*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            _result = servant->getCustomer(_current);
            return ::Ice::DispatchOK;
        }
        
    private:
        
        ::Ice::Int& _result;
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __CustomerRelationsManagement__order__getCustomer_name, ::Ice::Normal, __context);
    ::Ice::Int __result;
    try
    {
        _DirectI __direct(__result, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
    return __result;
}

void
IceDelegateD::CustomerRelationsManagement::order::setCustomer(::Ice::Int CustomerId, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::Ice::Int CustomerId, const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current),
            _m_CustomerId(CustomerId)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::CustomerRelationsManagement::order* servant = dynamic_cast< ::CustomerRelationsManagement::order*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            servant->setCustomer(_m_CustomerId, _current);
            return ::Ice::DispatchOK;
        }
        
    private:
        
        ::Ice::Int _m_CustomerId;
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __CustomerRelationsManagement__order__setCustomer_name, ::Ice::Normal, __context);
    try
    {
        _DirectI __direct(CustomerId, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
}

::std::string
IceDelegateD::CustomerRelationsManagement::order::getSrc(const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::std::string& __result, const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current),
            _result(__result)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::CustomerRelationsManagement::order* servant = dynamic_cast< ::CustomerRelationsManagement::order*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            _result = servant->getSrc(_current);
            return ::Ice::DispatchOK;
        }
        
    private:
        
        ::std::string& _result;
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __CustomerRelationsManagement__order__getSrc_name, ::Ice::Normal, __context);
    ::std::string __result;
    try
    {
        _DirectI __direct(__result, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
    return __result;
}

::std::string
IceDelegateD::CustomerRelationsManagement::order::getDst(const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::std::string& __result, const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current),
            _result(__result)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::CustomerRelationsManagement::order* servant = dynamic_cast< ::CustomerRelationsManagement::order*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            _result = servant->getDst(_current);
            return ::Ice::DispatchOK;
        }
        
    private:
        
        ::std::string& _result;
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __CustomerRelationsManagement__order__getDst_name, ::Ice::Normal, __context);
    ::std::string __result;
    try
    {
        _DirectI __direct(__result, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
    return __result;
}

void
IceDelegateD::CustomerRelationsManagement::order::setSrc(const ::std::string& src, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(const ::std::string& src, const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current),
            _m_src(src)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::CustomerRelationsManagement::order* servant = dynamic_cast< ::CustomerRelationsManagement::order*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            servant->setSrc(_m_src, _current);
            return ::Ice::DispatchOK;
        }
        
    private:
        
        const ::std::string& _m_src;
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __CustomerRelationsManagement__order__setSrc_name, ::Ice::Normal, __context);
    try
    {
        _DirectI __direct(src, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
}

void
IceDelegateD::CustomerRelationsManagement::order::setDst(const ::std::string& dst, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(const ::std::string& dst, const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current),
            _m_dst(dst)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::CustomerRelationsManagement::order* servant = dynamic_cast< ::CustomerRelationsManagement::order*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            servant->setDst(_m_dst, _current);
            return ::Ice::DispatchOK;
        }
        
    private:
        
        const ::std::string& _m_dst;
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __CustomerRelationsManagement__order__setDst_name, ::Ice::Normal, __context);
    try
    {
        _DirectI __direct(dst, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
}

::Ice::Float
IceDelegateD::CustomerRelationsManagement::order::getWeight(const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::Ice::Float& __result, const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current),
            _result(__result)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::CustomerRelationsManagement::order* servant = dynamic_cast< ::CustomerRelationsManagement::order*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            _result = servant->getWeight(_current);
            return ::Ice::DispatchOK;
        }
        
    private:
        
        ::Ice::Float& _result;
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __CustomerRelationsManagement__order__getWeight_name, ::Ice::Normal, __context);
    ::Ice::Float __result;
    try
    {
        _DirectI __direct(__result, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
    return __result;
}

void
IceDelegateD::CustomerRelationsManagement::order::setWeight(::Ice::Float weight, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::Ice::Float weight, const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current),
            _m_weight(weight)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::CustomerRelationsManagement::order* servant = dynamic_cast< ::CustomerRelationsManagement::order*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            servant->setWeight(_m_weight, _current);
            return ::Ice::DispatchOK;
        }
        
    private:
        
        ::Ice::Float _m_weight;
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __CustomerRelationsManagement__order__setWeight_name, ::Ice::Normal, __context);
    try
    {
        _DirectI __direct(weight, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
}

::CustomerRelationsManagement::datetime
IceDelegateD::CustomerRelationsManagement::order::getDeadline(const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::CustomerRelationsManagement::datetime& __result, const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current),
            _result(__result)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::CustomerRelationsManagement::order* servant = dynamic_cast< ::CustomerRelationsManagement::order*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            _result = servant->getDeadline(_current);
            return ::Ice::DispatchOK;
        }
        
    private:
        
        ::CustomerRelationsManagement::datetime& _result;
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __CustomerRelationsManagement__order__getDeadline_name, ::Ice::Normal, __context);
    ::CustomerRelationsManagement::datetime __result;
    try
    {
        _DirectI __direct(__result, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
    return __result;
}

void
IceDelegateD::CustomerRelationsManagement::order::setDeadline(const ::CustomerRelationsManagement::datetime& deadline, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(const ::CustomerRelationsManagement::datetime& deadline, const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current),
            _m_deadline(deadline)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::CustomerRelationsManagement::order* servant = dynamic_cast< ::CustomerRelationsManagement::order*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            servant->setDeadline(_m_deadline, _current);
            return ::Ice::DispatchOK;
        }
        
    private:
        
        const ::CustomerRelationsManagement::datetime& _m_deadline;
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __CustomerRelationsManagement__order__setDeadline_name, ::Ice::Normal, __context);
    try
    {
        _DirectI __direct(deadline, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
}

::CustomerRelationsManagement::OrderStatus
IceDelegateD::CustomerRelationsManagement::order::getStatus(const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::CustomerRelationsManagement::OrderStatus& __result, const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current),
            _result(__result)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::CustomerRelationsManagement::order* servant = dynamic_cast< ::CustomerRelationsManagement::order*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            _result = servant->getStatus(_current);
            return ::Ice::DispatchOK;
        }
        
    private:
        
        ::CustomerRelationsManagement::OrderStatus& _result;
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __CustomerRelationsManagement__order__getStatus_name, ::Ice::Normal, __context);
    ::CustomerRelationsManagement::OrderStatus __result;
    try
    {
        _DirectI __direct(__result, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
    return __result;
}

void
IceDelegateD::CustomerRelationsManagement::order::setStatus(::CustomerRelationsManagement::OrderStatus status, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::CustomerRelationsManagement::OrderStatus status, const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current),
            _m_status(status)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::CustomerRelationsManagement::order* servant = dynamic_cast< ::CustomerRelationsManagement::order*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            servant->setStatus(_m_status, _current);
            return ::Ice::DispatchOK;
        }
        
    private:
        
        ::CustomerRelationsManagement::OrderStatus _m_status;
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __CustomerRelationsManagement__order__setStatus_name, ::Ice::Normal, __context);
    try
    {
        _DirectI __direct(status, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
}

::CustomerRelationsManagement::customerPrx
IceDelegateD::CustomerRelationsManagement::CRM::CreateCustomer(const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::CustomerRelationsManagement::customerPrx& __result, const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current),
            _result(__result)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::CustomerRelationsManagement::CRM* servant = dynamic_cast< ::CustomerRelationsManagement::CRM*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            _result = servant->CreateCustomer(_current);
            return ::Ice::DispatchOK;
        }
        
    private:
        
        ::CustomerRelationsManagement::customerPrx& _result;
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __CustomerRelationsManagement__CRM__CreateCustomer_name, ::Ice::Normal, __context);
    ::CustomerRelationsManagement::customerPrx __result;
    try
    {
        _DirectI __direct(__result, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
    return __result;
}

::CustomerRelationsManagement::customerPrx
IceDelegateD::CustomerRelationsManagement::CRM::LoadCustomerByName(const ::std::string& CustName, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::CustomerRelationsManagement::customerPrx& __result, const ::std::string& CustName, const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current),
            _result(__result),
            _m_CustName(CustName)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::CustomerRelationsManagement::CRM* servant = dynamic_cast< ::CustomerRelationsManagement::CRM*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            try
            {
                _result = servant->LoadCustomerByName(_m_CustName, _current);
                return ::Ice::DispatchOK;
            }
            catch(const ::Ice::UserException& __ex)
            {
                setUserException(__ex);
                return ::Ice::DispatchUserException;
            }
        }
        
    private:
        
        ::CustomerRelationsManagement::customerPrx& _result;
        const ::std::string& _m_CustName;
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __CustomerRelationsManagement__CRM__LoadCustomerByName_name, ::Ice::Normal, __context);
    ::CustomerRelationsManagement::customerPrx __result;
    try
    {
        _DirectI __direct(__result, CustName, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::CustomerRelationsManagement::DBError&)
    {
        throw;
    }
    catch(const ::CustomerRelationsManagement::RecordNotFound&)
    {
        throw;
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
    return __result;
}

::CustomerRelationsManagement::customerPrx
IceDelegateD::CustomerRelationsManagement::CRM::LoadCustomerById(::Ice::Int CustId, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::CustomerRelationsManagement::customerPrx& __result, ::Ice::Int CustId, const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current),
            _result(__result),
            _m_CustId(CustId)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::CustomerRelationsManagement::CRM* servant = dynamic_cast< ::CustomerRelationsManagement::CRM*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            try
            {
                _result = servant->LoadCustomerById(_m_CustId, _current);
                return ::Ice::DispatchOK;
            }
            catch(const ::Ice::UserException& __ex)
            {
                setUserException(__ex);
                return ::Ice::DispatchUserException;
            }
        }
        
    private:
        
        ::CustomerRelationsManagement::customerPrx& _result;
        ::Ice::Int _m_CustId;
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __CustomerRelationsManagement__CRM__LoadCustomerById_name, ::Ice::Normal, __context);
    ::CustomerRelationsManagement::customerPrx __result;
    try
    {
        _DirectI __direct(__result, CustId, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::CustomerRelationsManagement::DBError&)
    {
        throw;
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
    return __result;
}

::CustomerRelationsManagement::orderPrx
IceDelegateD::CustomerRelationsManagement::CRM::CreateOrder(const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::CustomerRelationsManagement::orderPrx& __result, const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current),
            _result(__result)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::CustomerRelationsManagement::CRM* servant = dynamic_cast< ::CustomerRelationsManagement::CRM*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            _result = servant->CreateOrder(_current);
            return ::Ice::DispatchOK;
        }
        
    private:
        
        ::CustomerRelationsManagement::orderPrx& _result;
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __CustomerRelationsManagement__CRM__CreateOrder_name, ::Ice::Normal, __context);
    ::CustomerRelationsManagement::orderPrx __result;
    try
    {
        _DirectI __direct(__result, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
    return __result;
}

::CustomerRelationsManagement::orderPrx
IceDelegateD::CustomerRelationsManagement::CRM::LoadOrderById(::Ice::Int OrderId, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::CustomerRelationsManagement::orderPrx& __result, ::Ice::Int OrderId, const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current),
            _result(__result),
            _m_OrderId(OrderId)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::CustomerRelationsManagement::CRM* servant = dynamic_cast< ::CustomerRelationsManagement::CRM*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            try
            {
                _result = servant->LoadOrderById(_m_OrderId, _current);
                return ::Ice::DispatchOK;
            }
            catch(const ::Ice::UserException& __ex)
            {
                setUserException(__ex);
                return ::Ice::DispatchUserException;
            }
        }
        
    private:
        
        ::CustomerRelationsManagement::orderPrx& _result;
        ::Ice::Int _m_OrderId;
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __CustomerRelationsManagement__CRM__LoadOrderById_name, ::Ice::Normal, __context);
    ::CustomerRelationsManagement::orderPrx __result;
    try
    {
        _DirectI __direct(__result, OrderId, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::CustomerRelationsManagement::DBError&)
    {
        throw;
    }
    catch(const ::CustomerRelationsManagement::RecordNotFound&)
    {
        throw;
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
    return __result;
}

::CustomerRelationsManagement::OrderList
IceDelegateD::CustomerRelationsManagement::CRM::LoadOrderByCustomer(::Ice::Int CustId, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::CustomerRelationsManagement::OrderList& __result, ::Ice::Int CustId, const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current),
            _result(__result),
            _m_CustId(CustId)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::CustomerRelationsManagement::CRM* servant = dynamic_cast< ::CustomerRelationsManagement::CRM*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            try
            {
                _result = servant->LoadOrderByCustomer(_m_CustId, _current);
                return ::Ice::DispatchOK;
            }
            catch(const ::Ice::UserException& __ex)
            {
                setUserException(__ex);
                return ::Ice::DispatchUserException;
            }
        }
        
    private:
        
        ::CustomerRelationsManagement::OrderList& _result;
        ::Ice::Int _m_CustId;
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __CustomerRelationsManagement__CRM__LoadOrderByCustomer_name, ::Ice::Normal, __context);
    ::CustomerRelationsManagement::OrderList __result;
    try
    {
        _DirectI __direct(__result, CustId, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::CustomerRelationsManagement::DBError&)
    {
        throw;
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
    return __result;
}

::CustomerRelationsManagement::OrderList
IceDelegateD::CustomerRelationsManagement::CRM::LoadNewOrders(const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::CustomerRelationsManagement::OrderList& __result, const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current),
            _result(__result)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::CustomerRelationsManagement::CRM* servant = dynamic_cast< ::CustomerRelationsManagement::CRM*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            try
            {
                _result = servant->LoadNewOrders(_current);
                return ::Ice::DispatchOK;
            }
            catch(const ::Ice::UserException& __ex)
            {
                setUserException(__ex);
                return ::Ice::DispatchUserException;
            }
        }
        
    private:
        
        ::CustomerRelationsManagement::OrderList& _result;
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __CustomerRelationsManagement__CRM__LoadNewOrders_name, ::Ice::Normal, __context);
    ::CustomerRelationsManagement::OrderList __result;
    try
    {
        _DirectI __direct(__result, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::CustomerRelationsManagement::DBError&)
    {
        throw;
    }
    catch(const ::CustomerRelationsManagement::RecordNotFound&)
    {
        throw;
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
    return __result;
}

void
IceDelegateD::Optimization::OptimizationEngine::runTest(const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::Optimization::OptimizationEngine* servant = dynamic_cast< ::Optimization::OptimizationEngine*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            try
            {
                servant->runTest(_current);
                return ::Ice::DispatchOK;
            }
            catch(const ::Ice::UserException& __ex)
            {
                setUserException(__ex);
                return ::Ice::DispatchUserException;
            }
        }
        
    private:
        
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __Optimization__OptimizationEngine__runTest_name, ::Ice::Normal, __context);
    try
    {
        _DirectI __direct(__current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::Optimization::OptimizationEngineBusy&)
    {
        throw;
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
}

::Tracking::RouteData
IceDelegateD::Tracking::TrackingService::getAllData(const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::Tracking::RouteData& __result, const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current),
            _result(__result)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::Tracking::TrackingService* servant = dynamic_cast< ::Tracking::TrackingService*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            _result = servant->getAllData(_current);
            return ::Ice::DispatchOK;
        }
        
    private:
        
        ::Tracking::RouteData& _result;
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __Tracking__TrackingService__getAllData_name, ::Ice::Normal, __context);
    ::Tracking::RouteData __result;
    try
    {
        _DirectI __direct(__result, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
    return __result;
}

void
IceDelegateD::Tracking::TrackingService::postNewRoutes(const ::Tracking::RouteData& nrd, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(const ::Tracking::RouteData& nrd, const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current),
            _m_nrd(nrd)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::Tracking::TrackingService* servant = dynamic_cast< ::Tracking::TrackingService*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            servant->postNewRoutes(_m_nrd, _current);
            return ::Ice::DispatchOK;
        }
        
    private:
        
        const ::Tracking::RouteData& _m_nrd;
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __Tracking__TrackingService__postNewRoutes_name, ::Ice::Normal, __context);
    try
    {
        _DirectI __direct(nrd, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
}

::Ice::ObjectPtr
CustomerRelationsManagement::customer::ice_clone() const
{
    throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
    return 0; // to avoid a warning with some compilers
}

static const ::std::string __CustomerRelationsManagement__customer_ids[2] =
{
    "::CustomerRelationsManagement::customer",
    "::Ice::Object"
};

bool
CustomerRelationsManagement::customer::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__CustomerRelationsManagement__customer_ids, __CustomerRelationsManagement__customer_ids + 2, _s);
}

::std::vector< ::std::string>
CustomerRelationsManagement::customer::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__CustomerRelationsManagement__customer_ids[0], &__CustomerRelationsManagement__customer_ids[2]);
}

const ::std::string&
CustomerRelationsManagement::customer::ice_id(const ::Ice::Current&) const
{
    return __CustomerRelationsManagement__customer_ids[0];
}

const ::std::string&
CustomerRelationsManagement::customer::ice_staticId()
{
    return __CustomerRelationsManagement__customer_ids[0];
}

::Ice::DispatchStatus
CustomerRelationsManagement::customer::___getId(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.is()->skipEmptyEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    try
    {
        ::Ice::Int __ret = getId(__current);
        __os->write(__ret);
    }
    catch(const ::CustomerRelationsManagement::RecordNotCommitted& __ex)
    {
        __os->write(__ex);
        return ::Ice::DispatchUserException;
    }
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
CustomerRelationsManagement::customer::___save(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.is()->skipEmptyEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    try
    {
        save(__current);
    }
    catch(const ::CustomerRelationsManagement::DBError& __ex)
    {
        __os->write(__ex);
        return ::Ice::DispatchUserException;
    }
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
CustomerRelationsManagement::customer::___delete(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.is()->skipEmptyEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    try
    {
        _cpp_delete(__current);
    }
    catch(const ::CustomerRelationsManagement::DBError& __ex)
    {
        __os->write(__ex);
        return ::Ice::DispatchUserException;
    }
    catch(const ::CustomerRelationsManagement::RecordNotCommitted& __ex)
    {
        __os->write(__ex);
        return ::Ice::DispatchUserException;
    }
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
CustomerRelationsManagement::customer::___getName(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.is()->skipEmptyEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::std::string __ret = getName(__current);
    __os->write(__ret);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
CustomerRelationsManagement::customer::___setName(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::std::string name;
    __is->read(name);
    __is->endReadEncaps();
    setName(name, __current);
    return ::Ice::DispatchOK;
}

static ::std::string __CustomerRelationsManagement__customer_all[] =
{
    "delete",
    "getId",
    "getName",
    "ice_id",
    "ice_ids",
    "ice_isA",
    "ice_ping",
    "save",
    "setName"
};

::Ice::DispatchStatus
CustomerRelationsManagement::customer::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__CustomerRelationsManagement__customer_all, __CustomerRelationsManagement__customer_all + 9, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __CustomerRelationsManagement__customer_all)
    {
        case 0:
        {
            return ___delete(in, current);
        }
        case 1:
        {
            return ___getId(in, current);
        }
        case 2:
        {
            return ___getName(in, current);
        }
        case 3:
        {
            return ___ice_id(in, current);
        }
        case 4:
        {
            return ___ice_ids(in, current);
        }
        case 5:
        {
            return ___ice_isA(in, current);
        }
        case 6:
        {
            return ___ice_ping(in, current);
        }
        case 7:
        {
            return ___save(in, current);
        }
        case 8:
        {
            return ___setName(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}

void
CustomerRelationsManagement::customer::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__write(__os);
#else
    ::Ice::Object::__write(__os);
#endif
}

void
CustomerRelationsManagement::customer::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__read(__is, true);
#else
    ::Ice::Object::__read(__is, true);
#endif
}

void
CustomerRelationsManagement::customer::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type CustomerRelationsManagement::customer was not generated with stream support";
    throw ex;
}

void
CustomerRelationsManagement::customer::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type CustomerRelationsManagement::customer was not generated with stream support";
    throw ex;
}

void 
CustomerRelationsManagement::__patch__customerPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::CustomerRelationsManagement::customerPtr* p = static_cast< ::CustomerRelationsManagement::customerPtr*>(__addr);
    assert(p);
    *p = ::CustomerRelationsManagement::customerPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::CustomerRelationsManagement::customer::ice_staticId(), v->ice_id());
    }
}

bool
CustomerRelationsManagement::operator==(const ::CustomerRelationsManagement::customer& l, const ::CustomerRelationsManagement::customer& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
CustomerRelationsManagement::operator<(const ::CustomerRelationsManagement::customer& l, const ::CustomerRelationsManagement::customer& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

::Ice::ObjectPtr
CustomerRelationsManagement::order::ice_clone() const
{
    throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
    return 0; // to avoid a warning with some compilers
}

static const ::std::string __CustomerRelationsManagement__order_ids[2] =
{
    "::CustomerRelationsManagement::order",
    "::Ice::Object"
};

bool
CustomerRelationsManagement::order::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__CustomerRelationsManagement__order_ids, __CustomerRelationsManagement__order_ids + 2, _s);
}

::std::vector< ::std::string>
CustomerRelationsManagement::order::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__CustomerRelationsManagement__order_ids[0], &__CustomerRelationsManagement__order_ids[2]);
}

const ::std::string&
CustomerRelationsManagement::order::ice_id(const ::Ice::Current&) const
{
    return __CustomerRelationsManagement__order_ids[0];
}

const ::std::string&
CustomerRelationsManagement::order::ice_staticId()
{
    return __CustomerRelationsManagement__order_ids[0];
}

::Ice::DispatchStatus
CustomerRelationsManagement::order::___getId(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.is()->skipEmptyEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    try
    {
        ::Ice::Int __ret = getId(__current);
        __os->write(__ret);
    }
    catch(const ::CustomerRelationsManagement::RecordNotCommitted& __ex)
    {
        __os->write(__ex);
        return ::Ice::DispatchUserException;
    }
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
CustomerRelationsManagement::order::___save(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.is()->skipEmptyEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    try
    {
        save(__current);
    }
    catch(const ::CustomerRelationsManagement::DBError& __ex)
    {
        __os->write(__ex);
        return ::Ice::DispatchUserException;
    }
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
CustomerRelationsManagement::order::___delete(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.is()->skipEmptyEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    try
    {
        _cpp_delete(__current);
    }
    catch(const ::CustomerRelationsManagement::DBError& __ex)
    {
        __os->write(__ex);
        return ::Ice::DispatchUserException;
    }
    catch(const ::CustomerRelationsManagement::RecordNotCommitted& __ex)
    {
        __os->write(__ex);
        return ::Ice::DispatchUserException;
    }
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
CustomerRelationsManagement::order::___getCustomer(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.is()->skipEmptyEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::Ice::Int __ret = getCustomer(__current);
    __os->write(__ret);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
CustomerRelationsManagement::order::___setCustomer(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Ice::Int CustomerId;
    __is->read(CustomerId);
    __is->endReadEncaps();
    setCustomer(CustomerId, __current);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
CustomerRelationsManagement::order::___getSrc(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.is()->skipEmptyEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::std::string __ret = getSrc(__current);
    __os->write(__ret);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
CustomerRelationsManagement::order::___getDst(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.is()->skipEmptyEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::std::string __ret = getDst(__current);
    __os->write(__ret);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
CustomerRelationsManagement::order::___setSrc(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::std::string src;
    __is->read(src);
    __is->endReadEncaps();
    setSrc(src, __current);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
CustomerRelationsManagement::order::___setDst(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::std::string dst;
    __is->read(dst);
    __is->endReadEncaps();
    setDst(dst, __current);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
CustomerRelationsManagement::order::___getWeight(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.is()->skipEmptyEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::Ice::Float __ret = getWeight(__current);
    __os->write(__ret);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
CustomerRelationsManagement::order::___setWeight(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Ice::Float weight;
    __is->read(weight);
    __is->endReadEncaps();
    setWeight(weight, __current);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
CustomerRelationsManagement::order::___getDeadline(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.is()->skipEmptyEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::CustomerRelationsManagement::datetime __ret = getDeadline(__current);
    __ret.__write(__os);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
CustomerRelationsManagement::order::___setDeadline(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::CustomerRelationsManagement::datetime deadline;
    deadline.__read(__is);
    __is->endReadEncaps();
    setDeadline(deadline, __current);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
CustomerRelationsManagement::order::___getStatus(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.is()->skipEmptyEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::CustomerRelationsManagement::OrderStatus __ret = getStatus(__current);
    ::CustomerRelationsManagement::__write(__os, __ret);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
CustomerRelationsManagement::order::___setStatus(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::CustomerRelationsManagement::OrderStatus status;
    ::CustomerRelationsManagement::__read(__is, status);
    __is->endReadEncaps();
    setStatus(status, __current);
    return ::Ice::DispatchOK;
}

static ::std::string __CustomerRelationsManagement__order_all[] =
{
    "delete",
    "getCustomer",
    "getDeadline",
    "getDst",
    "getId",
    "getSrc",
    "getStatus",
    "getWeight",
    "ice_id",
    "ice_ids",
    "ice_isA",
    "ice_ping",
    "save",
    "setCustomer",
    "setDeadline",
    "setDst",
    "setSrc",
    "setStatus",
    "setWeight"
};

::Ice::DispatchStatus
CustomerRelationsManagement::order::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__CustomerRelationsManagement__order_all, __CustomerRelationsManagement__order_all + 19, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __CustomerRelationsManagement__order_all)
    {
        case 0:
        {
            return ___delete(in, current);
        }
        case 1:
        {
            return ___getCustomer(in, current);
        }
        case 2:
        {
            return ___getDeadline(in, current);
        }
        case 3:
        {
            return ___getDst(in, current);
        }
        case 4:
        {
            return ___getId(in, current);
        }
        case 5:
        {
            return ___getSrc(in, current);
        }
        case 6:
        {
            return ___getStatus(in, current);
        }
        case 7:
        {
            return ___getWeight(in, current);
        }
        case 8:
        {
            return ___ice_id(in, current);
        }
        case 9:
        {
            return ___ice_ids(in, current);
        }
        case 10:
        {
            return ___ice_isA(in, current);
        }
        case 11:
        {
            return ___ice_ping(in, current);
        }
        case 12:
        {
            return ___save(in, current);
        }
        case 13:
        {
            return ___setCustomer(in, current);
        }
        case 14:
        {
            return ___setDeadline(in, current);
        }
        case 15:
        {
            return ___setDst(in, current);
        }
        case 16:
        {
            return ___setSrc(in, current);
        }
        case 17:
        {
            return ___setStatus(in, current);
        }
        case 18:
        {
            return ___setWeight(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}

void
CustomerRelationsManagement::order::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__write(__os);
#else
    ::Ice::Object::__write(__os);
#endif
}

void
CustomerRelationsManagement::order::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__read(__is, true);
#else
    ::Ice::Object::__read(__is, true);
#endif
}

void
CustomerRelationsManagement::order::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type CustomerRelationsManagement::order was not generated with stream support";
    throw ex;
}

void
CustomerRelationsManagement::order::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type CustomerRelationsManagement::order was not generated with stream support";
    throw ex;
}

void 
CustomerRelationsManagement::__patch__orderPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::CustomerRelationsManagement::orderPtr* p = static_cast< ::CustomerRelationsManagement::orderPtr*>(__addr);
    assert(p);
    *p = ::CustomerRelationsManagement::orderPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::CustomerRelationsManagement::order::ice_staticId(), v->ice_id());
    }
}

bool
CustomerRelationsManagement::operator==(const ::CustomerRelationsManagement::order& l, const ::CustomerRelationsManagement::order& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
CustomerRelationsManagement::operator<(const ::CustomerRelationsManagement::order& l, const ::CustomerRelationsManagement::order& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

::Ice::ObjectPtr
CustomerRelationsManagement::CRM::ice_clone() const
{
    throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
    return 0; // to avoid a warning with some compilers
}

static const ::std::string __CustomerRelationsManagement__CRM_ids[2] =
{
    "::CustomerRelationsManagement::CRM",
    "::Ice::Object"
};

bool
CustomerRelationsManagement::CRM::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__CustomerRelationsManagement__CRM_ids, __CustomerRelationsManagement__CRM_ids + 2, _s);
}

::std::vector< ::std::string>
CustomerRelationsManagement::CRM::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__CustomerRelationsManagement__CRM_ids[0], &__CustomerRelationsManagement__CRM_ids[2]);
}

const ::std::string&
CustomerRelationsManagement::CRM::ice_id(const ::Ice::Current&) const
{
    return __CustomerRelationsManagement__CRM_ids[0];
}

const ::std::string&
CustomerRelationsManagement::CRM::ice_staticId()
{
    return __CustomerRelationsManagement__CRM_ids[0];
}

::Ice::DispatchStatus
CustomerRelationsManagement::CRM::___CreateCustomer(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.is()->skipEmptyEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::CustomerRelationsManagement::customerPrx __ret = CreateCustomer(__current);
    __os->write(::Ice::ObjectPrx(::IceInternal::upCast(__ret.get())));
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
CustomerRelationsManagement::CRM::___LoadCustomerByName(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::std::string CustName;
    __is->read(CustName);
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    try
    {
        ::CustomerRelationsManagement::customerPrx __ret = LoadCustomerByName(CustName, __current);
        __os->write(::Ice::ObjectPrx(::IceInternal::upCast(__ret.get())));
    }
    catch(const ::CustomerRelationsManagement::DBError& __ex)
    {
        __os->write(__ex);
        return ::Ice::DispatchUserException;
    }
    catch(const ::CustomerRelationsManagement::RecordNotFound& __ex)
    {
        __os->write(__ex);
        return ::Ice::DispatchUserException;
    }
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
CustomerRelationsManagement::CRM::___LoadCustomerById(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Ice::Int CustId;
    __is->read(CustId);
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    try
    {
        ::CustomerRelationsManagement::customerPrx __ret = LoadCustomerById(CustId, __current);
        __os->write(::Ice::ObjectPrx(::IceInternal::upCast(__ret.get())));
    }
    catch(const ::CustomerRelationsManagement::DBError& __ex)
    {
        __os->write(__ex);
        return ::Ice::DispatchUserException;
    }
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
CustomerRelationsManagement::CRM::___CreateOrder(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.is()->skipEmptyEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::CustomerRelationsManagement::orderPrx __ret = CreateOrder(__current);
    __os->write(::Ice::ObjectPrx(::IceInternal::upCast(__ret.get())));
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
CustomerRelationsManagement::CRM::___LoadOrderById(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Ice::Int OrderId;
    __is->read(OrderId);
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    try
    {
        ::CustomerRelationsManagement::orderPrx __ret = LoadOrderById(OrderId, __current);
        __os->write(::Ice::ObjectPrx(::IceInternal::upCast(__ret.get())));
    }
    catch(const ::CustomerRelationsManagement::DBError& __ex)
    {
        __os->write(__ex);
        return ::Ice::DispatchUserException;
    }
    catch(const ::CustomerRelationsManagement::RecordNotFound& __ex)
    {
        __os->write(__ex);
        return ::Ice::DispatchUserException;
    }
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
CustomerRelationsManagement::CRM::___LoadOrderByCustomer(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Ice::Int CustId;
    __is->read(CustId);
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    try
    {
        ::CustomerRelationsManagement::OrderList __ret = LoadOrderByCustomer(CustId, __current);
        if(__ret.size() == 0)
        {
            __os->writeSize(0);
        }
        else
        {
            ::CustomerRelationsManagement::__writeOrderList(__os, &__ret[0], &__ret[0] + __ret.size());
        }
    }
    catch(const ::CustomerRelationsManagement::DBError& __ex)
    {
        __os->write(__ex);
        return ::Ice::DispatchUserException;
    }
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
CustomerRelationsManagement::CRM::___LoadNewOrders(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.is()->skipEmptyEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    try
    {
        ::CustomerRelationsManagement::OrderList __ret = LoadNewOrders(__current);
        if(__ret.size() == 0)
        {
            __os->writeSize(0);
        }
        else
        {
            ::CustomerRelationsManagement::__writeOrderList(__os, &__ret[0], &__ret[0] + __ret.size());
        }
    }
    catch(const ::CustomerRelationsManagement::DBError& __ex)
    {
        __os->write(__ex);
        return ::Ice::DispatchUserException;
    }
    catch(const ::CustomerRelationsManagement::RecordNotFound& __ex)
    {
        __os->write(__ex);
        return ::Ice::DispatchUserException;
    }
    return ::Ice::DispatchOK;
}

static ::std::string __CustomerRelationsManagement__CRM_all[] =
{
    "CreateCustomer",
    "CreateOrder",
    "LoadCustomerById",
    "LoadCustomerByName",
    "LoadNewOrders",
    "LoadOrderByCustomer",
    "LoadOrderById",
    "ice_id",
    "ice_ids",
    "ice_isA",
    "ice_ping"
};

::Ice::DispatchStatus
CustomerRelationsManagement::CRM::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__CustomerRelationsManagement__CRM_all, __CustomerRelationsManagement__CRM_all + 11, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __CustomerRelationsManagement__CRM_all)
    {
        case 0:
        {
            return ___CreateCustomer(in, current);
        }
        case 1:
        {
            return ___CreateOrder(in, current);
        }
        case 2:
        {
            return ___LoadCustomerById(in, current);
        }
        case 3:
        {
            return ___LoadCustomerByName(in, current);
        }
        case 4:
        {
            return ___LoadNewOrders(in, current);
        }
        case 5:
        {
            return ___LoadOrderByCustomer(in, current);
        }
        case 6:
        {
            return ___LoadOrderById(in, current);
        }
        case 7:
        {
            return ___ice_id(in, current);
        }
        case 8:
        {
            return ___ice_ids(in, current);
        }
        case 9:
        {
            return ___ice_isA(in, current);
        }
        case 10:
        {
            return ___ice_ping(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}

void
CustomerRelationsManagement::CRM::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__write(__os);
#else
    ::Ice::Object::__write(__os);
#endif
}

void
CustomerRelationsManagement::CRM::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__read(__is, true);
#else
    ::Ice::Object::__read(__is, true);
#endif
}

void
CustomerRelationsManagement::CRM::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type CustomerRelationsManagement::CRM was not generated with stream support";
    throw ex;
}

void
CustomerRelationsManagement::CRM::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type CustomerRelationsManagement::CRM was not generated with stream support";
    throw ex;
}

void 
CustomerRelationsManagement::__patch__CRMPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::CustomerRelationsManagement::CRMPtr* p = static_cast< ::CustomerRelationsManagement::CRMPtr*>(__addr);
    assert(p);
    *p = ::CustomerRelationsManagement::CRMPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::CustomerRelationsManagement::CRM::ice_staticId(), v->ice_id());
    }
}

bool
CustomerRelationsManagement::operator==(const ::CustomerRelationsManagement::CRM& l, const ::CustomerRelationsManagement::CRM& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
CustomerRelationsManagement::operator<(const ::CustomerRelationsManagement::CRM& l, const ::CustomerRelationsManagement::CRM& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

::Ice::ObjectPtr
Optimization::OptimizationEngine::ice_clone() const
{
    throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
    return 0; // to avoid a warning with some compilers
}

static const ::std::string __Optimization__OptimizationEngine_ids[2] =
{
    "::Ice::Object",
    "::Optimization::OptimizationEngine"
};

bool
Optimization::OptimizationEngine::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__Optimization__OptimizationEngine_ids, __Optimization__OptimizationEngine_ids + 2, _s);
}

::std::vector< ::std::string>
Optimization::OptimizationEngine::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__Optimization__OptimizationEngine_ids[0], &__Optimization__OptimizationEngine_ids[2]);
}

const ::std::string&
Optimization::OptimizationEngine::ice_id(const ::Ice::Current&) const
{
    return __Optimization__OptimizationEngine_ids[1];
}

const ::std::string&
Optimization::OptimizationEngine::ice_staticId()
{
    return __Optimization__OptimizationEngine_ids[1];
}

::Ice::DispatchStatus
Optimization::OptimizationEngine::___runTest(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.is()->skipEmptyEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    try
    {
        runTest(__current);
    }
    catch(const ::Optimization::OptimizationEngineBusy& __ex)
    {
        __os->write(__ex);
        return ::Ice::DispatchUserException;
    }
    return ::Ice::DispatchOK;
}

static ::std::string __Optimization__OptimizationEngine_all[] =
{
    "ice_id",
    "ice_ids",
    "ice_isA",
    "ice_ping",
    "runTest"
};

::Ice::DispatchStatus
Optimization::OptimizationEngine::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__Optimization__OptimizationEngine_all, __Optimization__OptimizationEngine_all + 5, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __Optimization__OptimizationEngine_all)
    {
        case 0:
        {
            return ___ice_id(in, current);
        }
        case 1:
        {
            return ___ice_ids(in, current);
        }
        case 2:
        {
            return ___ice_isA(in, current);
        }
        case 3:
        {
            return ___ice_ping(in, current);
        }
        case 4:
        {
            return ___runTest(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}

void
Optimization::OptimizationEngine::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__write(__os);
#else
    ::Ice::Object::__write(__os);
#endif
}

void
Optimization::OptimizationEngine::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__read(__is, true);
#else
    ::Ice::Object::__read(__is, true);
#endif
}

void
Optimization::OptimizationEngine::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type Optimization::OptimizationEngine was not generated with stream support";
    throw ex;
}

void
Optimization::OptimizationEngine::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type Optimization::OptimizationEngine was not generated with stream support";
    throw ex;
}

void 
Optimization::__patch__OptimizationEnginePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::Optimization::OptimizationEnginePtr* p = static_cast< ::Optimization::OptimizationEnginePtr*>(__addr);
    assert(p);
    *p = ::Optimization::OptimizationEnginePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::Optimization::OptimizationEngine::ice_staticId(), v->ice_id());
    }
}

bool
Optimization::operator==(const ::Optimization::OptimizationEngine& l, const ::Optimization::OptimizationEngine& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
Optimization::operator<(const ::Optimization::OptimizationEngine& l, const ::Optimization::OptimizationEngine& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

::Ice::ObjectPtr
Tracking::TrackingService::ice_clone() const
{
    throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
    return 0; // to avoid a warning with some compilers
}

static const ::std::string __Tracking__TrackingService_ids[2] =
{
    "::Ice::Object",
    "::Tracking::TrackingService"
};

bool
Tracking::TrackingService::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__Tracking__TrackingService_ids, __Tracking__TrackingService_ids + 2, _s);
}

::std::vector< ::std::string>
Tracking::TrackingService::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__Tracking__TrackingService_ids[0], &__Tracking__TrackingService_ids[2]);
}

const ::std::string&
Tracking::TrackingService::ice_id(const ::Ice::Current&) const
{
    return __Tracking__TrackingService_ids[1];
}

const ::std::string&
Tracking::TrackingService::ice_staticId()
{
    return __Tracking__TrackingService_ids[1];
}

::Ice::DispatchStatus
Tracking::TrackingService::___getAllData(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.is()->skipEmptyEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::Tracking::RouteData __ret = getAllData(__current);
    __ret.__write(__os);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Tracking::TrackingService::___postNewRoutes(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Tracking::RouteData nrd;
    nrd.__read(__is);
    __is->endReadEncaps();
    postNewRoutes(nrd, __current);
    return ::Ice::DispatchOK;
}

static ::std::string __Tracking__TrackingService_all[] =
{
    "getAllData",
    "ice_id",
    "ice_ids",
    "ice_isA",
    "ice_ping",
    "postNewRoutes"
};

::Ice::DispatchStatus
Tracking::TrackingService::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__Tracking__TrackingService_all, __Tracking__TrackingService_all + 6, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __Tracking__TrackingService_all)
    {
        case 0:
        {
            return ___getAllData(in, current);
        }
        case 1:
        {
            return ___ice_id(in, current);
        }
        case 2:
        {
            return ___ice_ids(in, current);
        }
        case 3:
        {
            return ___ice_isA(in, current);
        }
        case 4:
        {
            return ___ice_ping(in, current);
        }
        case 5:
        {
            return ___postNewRoutes(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}

void
Tracking::TrackingService::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__write(__os);
#else
    ::Ice::Object::__write(__os);
#endif
}

void
Tracking::TrackingService::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__read(__is, true);
#else
    ::Ice::Object::__read(__is, true);
#endif
}

void
Tracking::TrackingService::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type Tracking::TrackingService was not generated with stream support";
    throw ex;
}

void
Tracking::TrackingService::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type Tracking::TrackingService was not generated with stream support";
    throw ex;
}

void 
Tracking::__patch__TrackingServicePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::Tracking::TrackingServicePtr* p = static_cast< ::Tracking::TrackingServicePtr*>(__addr);
    assert(p);
    *p = ::Tracking::TrackingServicePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::Tracking::TrackingService::ice_staticId(), v->ice_id());
    }
}

bool
Tracking::operator==(const ::Tracking::TrackingService& l, const ::Tracking::TrackingService& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
Tracking::operator<(const ::Tracking::TrackingService& l, const ::Tracking::TrackingService& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}
